@eagleoutice/flowr 1.5.1 → 2.0.0

package/dataflow/internal/process/functions/call/common.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchFunctionCall = exports.processAllArguments = void 0;
+const processor_1 = require("../../../../processor");
+const r_function_call_1 = require("../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const overwrite_1 = require("../../../../environments/overwrite");
+const resolve_by_name_1 = require("../../../../environments/resolve-by-name");
+function processAllArguments({ functionName, args, data, finalGraph, functionRootId, patchData = d => d }) {
+    let finalEnv = functionName.environment;
+    // arg env contains the environments with other args defined
+    let argEnv = functionName.environment;
+    const callArgs = [];
+    const processedArguments = [];
+    const remainingReadInArgs = [];
+    let i = -1;
+    for (const arg of args) {
+        i++;
+        data = patchData(data, i);
+        if (arg === r_function_call_1.EmptyArgument) {
+            callArgs.push(r_function_call_1.EmptyArgument);
+            processedArguments.push(undefined);
+            continue;
+        }
+        const processed = (0, processor_1.processDataflowFor)(arg, { ...data, environment: argEnv });
+        processedArguments.push(processed);
+        finalEnv = (0, overwrite_1.overwriteEnvironment)(finalEnv, processed.environment);
+        // resolve reads within argument, we resolve before adding the `processed.environment` to avoid cyclic dependencies
+        for (const ingoing of [...processed.in, ...processed.unknownReferences]) {
+            const tryToResolve = ingoing.name ? (0, resolve_by_name_1.resolveByName)(ingoing.name, argEnv) : undefined;
+            if (tryToResolve === undefined) {
+                remainingReadInArgs.push(ingoing);
+            }
+            else {
+                for (const resolved of tryToResolve) {
+                    finalGraph.addEdge(ingoing.nodeId, resolved.nodeId, { type: 1 /* EdgeType.Reads */ });
+                }
+            }
+        }
+        argEnv = (0, overwrite_1.overwriteEnvironment)(argEnv, processed.environment);
+        finalGraph.mergeWith(processed.graph);
+        if (arg.type !== "RArgument" /* RType.Argument */ || !arg.name) {
+            callArgs.push({ nodeId: processed.entryPoint, controlDependencies: undefined });
+        }
+        else {
+            callArgs.push({ nodeId: processed.entryPoint, name: arg.name.content, controlDependencies: undefined });
+        }
+        finalGraph.addEdge(functionRootId, processed.entryPoint, { type: 64 /* EdgeType.Argument */ });
+    }
+    return { finalEnv, callArgs, remainingReadInArgs, processedArguments };
+}
+exports.processAllArguments = processAllArguments;
+function patchFunctionCall({ nextGraph, rootId, name, data, argumentProcessResult }) {
+    nextGraph.addVertex({
+        tag: "function-call" /* VertexType.FunctionCall */,
+        id: rootId,
+        name: name.content,
+        environment: data.environment,
+        /* will be overwritten accordingly */
+        onlyBuiltin: false,
+        controlDependencies: data.controlDependencies,
+        args: argumentProcessResult.map(arg => arg === undefined ? r_function_call_1.EmptyArgument : { nodeId: arg.entryPoint, controlDependencies: undefined })
+    });
+    for (const arg of argumentProcessResult) {
+        if (arg) {
+            nextGraph.addEdge(rootId, arg.entryPoint, { type: 64 /* EdgeType.Argument */ });
+        }
+    }
+}
+exports.patchFunctionCall = patchFunctionCall;
+//# sourceMappingURL=common.js.map

package/dataflow/internal/process/functions/call/default-call-handling.d.ts

@@ -0,0 +1,5 @@
+import type { DataflowInformation } from '../../../../info';
+import type { DataflowProcessorInformation } from '../../../../processor';
+import type { ParentInformation } from '../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { RFunctionCall } from '../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+export declare function processFunctionCall<OtherInfo>(functionCall: RFunctionCall<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/functions/call/default-call-handling.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processFunctionCall = void 0;
+const named_call_handling_1 = require("./named-call-handling");
+const unnamed_call_handling_1 = require("./unnamed-call-handling");
+function processFunctionCall(functionCall, data) {
+    if (functionCall.flavor === 'named') {
+        return (0, named_call_handling_1.processNamedCall)(functionCall.functionName, functionCall.arguments, functionCall.info.id, data);
+    }
+    else {
+        return (0, unnamed_call_handling_1.processUnnamedFunctionCall)(functionCall, data);
+    }
+}
+exports.processFunctionCall = processFunctionCall;
+//# sourceMappingURL=default-call-handling.js.map

package/dataflow/internal/process/functions/call/known-call-handling.d.ts

@@ -0,0 +1,26 @@
+import type { DataflowProcessorInformation } from '../../../../processor';
+import type { DataflowInformation } from '../../../../info';
+import type { RSymbol } from '../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
+import type { ParentInformation } from '../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { RFunctionArgument } from '../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import type { NodeId } from '../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { RNode } from '../../../../../r-bridge/lang-4.x/ast/model/model';
+import type { IdentifierReference } from '../../../../environments/identifier';
+import { DataflowGraph } from '../../../../graph/graph';
+export interface ProcessKnownFunctionCallInput<OtherInfo> {
+    readonly name: RSymbol<OtherInfo & ParentInformation>;
+    readonly args: readonly (RNode<OtherInfo & ParentInformation> | RFunctionArgument<OtherInfo & ParentInformation>)[];
+    readonly rootId: NodeId;
+    readonly data: DataflowProcessorInformation<OtherInfo & ParentInformation>;
+    readonly reverseOrder?: boolean;
+    /** which arguments are to be marked as {@link EdgeType#NonStandardEvaluation|non-standard-evaluation}? */
+    readonly markAsNSE?: readonly number[];
+    readonly patchData?: (data: DataflowProcessorInformation<OtherInfo & ParentInformation>, arg: number) => DataflowProcessorInformation<OtherInfo & ParentInformation>;
+}
+export interface ProcessKnownFunctionCallResult {
+    readonly information: DataflowInformation;
+    readonly processedArguments: readonly (DataflowInformation | undefined)[];
+    readonly fnRef: IdentifierReference;
+}
+export declare function markNonStandardEvaluationEdges(markAsNSE: readonly number[] | undefined, callArgs: readonly (DataflowInformation | undefined)[], finalGraph: DataflowGraph, rootId: NodeId): void;
+export declare function processKnownFunctionCall<OtherInfo>({ name, args, rootId, data, reverseOrder, markAsNSE, patchData }: ProcessKnownFunctionCallInput<OtherInfo>): ProcessKnownFunctionCallResult;

package/dataflow/internal/process/functions/call/known-call-handling.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processKnownFunctionCall = exports.markNonStandardEvaluationEdges = void 0;
+const processor_1 = require("../../../../processor");
+const common_1 = require("./common");
+const graph_1 = require("../../../../graph/graph");
+const logger_1 = require("../../../../logger");
+function markNonStandardEvaluationEdges(markAsNSE, callArgs, finalGraph, rootId) {
+    if (markAsNSE === undefined) {
+        return;
+    }
+    for (const nse of markAsNSE) {
+        if (nse < callArgs.length) {
+            const arg = callArgs[nse];
+            if (arg !== undefined) {
+                finalGraph.addEdge(rootId, arg.entryPoint, { type: 256 /* EdgeType.NonStandardEvaluation */ });
+            }
+        }
+        else {
+            logger_1.dataflowLogger.warn(`Trying to mark argument ${nse} as non-standard-evaluation, but only ${callArgs.length} arguments are available`);
+        }
+    }
+}
+exports.markNonStandardEvaluationEdges = markNonStandardEvaluationEdges;
+function processKnownFunctionCall({ name, args, rootId, data, reverseOrder = false, markAsNSE = undefined, patchData = d => d }) {
+    const functionName = (0, processor_1.processDataflowFor)(name, data);
+    const finalGraph = new graph_1.DataflowGraph(data.completeAst.idMap);
+    const functionCallName = name.content;
+    logger_1.dataflowLogger.debug(`Using ${rootId} (name: ${functionCallName}) as root for the named function call`);
+    const processArgs = reverseOrder ? [...args].reverse() : args;
+    const { finalEnv, callArgs, remainingReadInArgs, processedArguments } = (0, common_1.processAllArguments)({ functionName, args: processArgs, data, finalGraph, functionRootId: rootId, patchData });
+    markNonStandardEvaluationEdges(markAsNSE, processedArguments, finalGraph, rootId);
+    finalGraph.addVertex({
+        tag: "function-call" /* VertexType.FunctionCall */,
+        id: rootId,
+        environment: data.environment,
+        name: functionCallName,
+        /* will be overwritten accordingly */
+        onlyBuiltin: false,
+        controlDependencies: data.controlDependencies,
+        args: reverseOrder ? [...callArgs].reverse() : callArgs
+    });
+    const inIds = remainingReadInArgs;
+    const fnRef = { nodeId: rootId, name: functionCallName, controlDependencies: data.controlDependencies };
+    inIds.push(fnRef);
+    return {
+        information: {
+            unknownReferences: [],
+            in: inIds,
+            /* we do not keep the argument out as it has been linked by the function */
+            out: functionName.out,
+            graph: finalGraph,
+            environment: finalEnv,
+            entryPoint: rootId,
+            exitPoints: [{ nodeId: rootId, type: 0 /* ExitPointType.Default */, controlDependencies: data.controlDependencies }]
+        },
+        processedArguments: reverseOrder ? [...processedArguments].reverse() : processedArguments,
+        fnRef
+    };
+}
+exports.processKnownFunctionCall = processKnownFunctionCall;
+//# sourceMappingURL=known-call-handling.js.map

package/dataflow/internal/process/functions/call/named-call-handling.d.ts

@@ -0,0 +1,7 @@
+import type { DataflowProcessorInformation } from '../../../../processor';
+import type { DataflowInformation } from '../../../../info';
+import type { ParentInformation } from '../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { RFunctionArgument } from '../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import type { RSymbol } from '../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
+import type { NodeId } from '../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+export declare function processNamedCall<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/functions/call/named-call-handling.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processNamedCall = void 0;
+const info_1 = require("../../../../info");
+const known_call_handling_1 = require("./known-call-handling");
+const append_1 = require("../../../../environments/append");
+const resolve_by_name_1 = require("../../../../environments/resolve-by-name");
+function mergeInformation(info, newInfo) {
+    if (info === undefined) {
+        return newInfo;
+    }
+    return {
+        unknownReferences: [...info.unknownReferences, ...newInfo.unknownReferences],
+        in: [...info.in, ...newInfo.in],
+        out: [...info.out, ...newInfo.out],
+        graph: info.graph.mergeWith(newInfo.graph),
+        environment: (0, append_1.appendEnvironment)(info.environment, newInfo.environment),
+        entryPoint: newInfo.entryPoint,
+        exitPoints: [...info.exitPoints, ...newInfo.exitPoints],
+    };
+}
+function processDefaultFunctionProcessor(information, name, args, rootId, data) {
+    const call = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data });
+    return mergeInformation(information, call.information);
+}
+function processNamedCall(name, args, rootId, data) {
+    const resolved = (0, resolve_by_name_1.resolveByName)(name.content, data.environment) ?? [];
+    let defaultProcessor = resolved.length === 0;
+    let information = undefined;
+    let builtIn = false;
+    for (const resolvedFunction of resolved) {
+        if (resolvedFunction.kind === 'built-in-function') {
+            builtIn = true;
+            information = mergeInformation(information, resolvedFunction.processor(name, args, rootId, data));
+        }
+        else {
+            defaultProcessor = true;
+        }
+    }
+    if (defaultProcessor) {
+        information = processDefaultFunctionProcessor(information, name, args, rootId, data);
+    }
+    else if (information && builtIn) {
+        // mark the function call as built in only
+        const v = information.graph.getVertex(rootId);
+        if (v?.tag === "function-call" /* VertexType.FunctionCall */) {
+            v.onlyBuiltin = true;
+        }
+    }
+    return information ?? (0, info_1.initializeCleanDataflowInformation)(rootId, data);
+}
+exports.processNamedCall = processNamedCall;
+//# sourceMappingURL=named-call-handling.js.map

package/dataflow/internal/process/functions/call/unnamed-call-handling.d.ts

@@ -0,0 +1,6 @@
+import type { DataflowProcessorInformation } from '../../../../processor';
+import type { DataflowInformation } from '../../../../info';
+import type { RUnnamedFunctionCall } from '../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import type { ParentInformation } from '../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+export declare const UnnamedFunctionCallPrefix = "unnamed-function-call-";
+export declare function processUnnamedFunctionCall<OtherInfo>(functionCall: RUnnamedFunctionCall<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/functions/call/unnamed-call-handling.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processUnnamedFunctionCall = exports.UnnamedFunctionCallPrefix = void 0;
+const processor_1 = require("../../../../processor");
+const common_1 = require("./common");
+const linker_1 = require("../../../linker");
+const graph_1 = require("../../../../graph/graph");
+const logger_1 = require("../../../../logger");
+exports.UnnamedFunctionCallPrefix = 'unnamed-function-call-';
+function processUnnamedFunctionCall(functionCall, data) {
+    const calledFunction = (0, processor_1.processDataflowFor)(functionCall.calledFunction, data);
+    const finalGraph = new graph_1.DataflowGraph(data.completeAst.idMap);
+    const functionRootId = functionCall.info.id;
+    const calledRootId = functionCall.calledFunction.info.id;
+    const functionCallName = `${exports.UnnamedFunctionCallPrefix}${functionRootId}`;
+    logger_1.dataflowLogger.debug(`Using ${functionRootId} as root for the unnamed function call`);
+    // we know that it calls the toplevel:
+    finalGraph.addEdge(functionRootId, calledRootId, { type: 4 /* EdgeType.Calls */ });
+    finalGraph.addEdge(functionRootId, calledRootId, { type: 1 /* EdgeType.Reads */ });
+    // keep the defined function
+    finalGraph.mergeWith(calledFunction.graph);
+    const { finalEnv, callArgs, remainingReadInArgs } = (0, common_1.processAllArguments)({
+        functionName: calledFunction,
+        args: functionCall.arguments,
+        data,
+        finalGraph,
+        functionRootId
+    });
+    finalGraph.addVertex({
+        tag: "function-call" /* VertexType.FunctionCall */,
+        id: functionRootId,
+        environment: data.environment,
+        name: functionCallName,
+        /* can never be a direct built-in-call */
+        onlyBuiltin: false,
+        controlDependencies: data.controlDependencies,
+        args: callArgs // same reference
+    });
+    const inIds = remainingReadInArgs;
+    inIds.push({ nodeId: functionRootId, name: functionCallName, controlDependencies: data.controlDependencies });
+    if (functionCall.calledFunction.type === "RFunctionDefinition" /* RType.FunctionDefinition */) {
+        (0, linker_1.linkArgumentsOnCall)(callArgs, functionCall.calledFunction.parameters, finalGraph);
+    }
+    // push the called function to the ids:
+    inIds.push(...calledFunction.in, ...calledFunction.unknownReferences);
+    return {
+        unknownReferences: [],
+        in: inIds,
+        // we do not keep the argument out as it has been linked by the function
+        out: calledFunction.out,
+        graph: finalGraph,
+        environment: finalEnv,
+        entryPoint: calledRootId,
+        exitPoints: calledFunction.exitPoints
+    };
+}
+exports.processUnnamedFunctionCall = processUnnamedFunctionCall;
+//# sourceMappingURL=unnamed-call-handling.js.map

package/dataflow/internal/process/functions/process-argument.d.ts

@@ -0,0 +1,9 @@
+import type { DataflowProcessorInformation } from '../../../processor';
+import type { DataflowInformation } from '../../../info';
+import type { ParentInformation } from '../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { RNode } from '../../../../r-bridge/lang-4.x/ast/model/model';
+import type { IdentifierReference } from '../../../environments/identifier';
+import { DataflowGraph } from '../../../graph/graph';
+import type { RArgument } from '../../../../r-bridge/lang-4.x/ast/model/nodes/r-argument';
+export declare function linkReadsForArgument<OtherInfo>(root: RNode<OtherInfo & ParentInformation>, ingoingRefs: readonly IdentifierReference[], graph: DataflowGraph): void;
+export declare function processFunctionArgument<OtherInfo>(argument: RArgument<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/functions/{argument.js → process-argument.js}

@@ -1,17 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processFunctionArgument = exports.linkReadsForArgument = exports.UnnamedArgumentPrefix = void 0;
+exports.processFunctionArgument = exports.linkReadsForArgument = void 0;
 const processor_1 = require("../../../processor");
-const r_bridge_1 = require("../../../../r-bridge");
-const graph_1 = require("../../../graph");
-const scopes_1 = require("../../../environments/scopes");
-exports.UnnamedArgumentPrefix = 'unnamed-argument-';
+const collect_1 = require("../../../../r-bridge/lang-4.x/ast/model/collect");
+const graph_1 = require("../../../graph/graph");
 function linkReadsForArgument(root, ingoingRefs, graph) {
-    const allIdsBeforeArguments = new Set((0, r_bridge_1.collectAllIds)(root, n => n.type === "RArgument" /* RType.Argument */ && n.info.id !== root.info.id));
+    const allIdsBeforeArguments = new Set((0, collect_1.collectAllIds)(root, n => n.type === "RArgument" /* RType.Argument */ && n.info.id !== root.info.id));
     const ingoingBeforeArgs = ingoingRefs.filter(r => allIdsBeforeArguments.has(r.nodeId));
     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, graph_1.EdgeType.Reads, 'always');
+        graph.addEdge(root.info.id, ref, { type: 1 /* EdgeType.Reads */ });
     }
 }
 exports.linkReadsForArgument = linkReadsForArgument;
@@ -19,28 +17,35 @@ function processFunctionArgument(argument, data) {
     const name = argument.name === undefined ? undefined : (0, processor_1.processDataflowFor)(argument.name, data);
     const value = argument.value === undefined ? undefined : (0, processor_1.processDataflowFor)(argument.value, data);
     // we do not keep the graph of the name, as this is no node that should ever exist
-    const graph = value?.graph ?? new graph_1.DataflowGraph();
-    const argContent = argument.name?.content;
-    const argumentName = argContent ?? `${exports.UnnamedArgumentPrefix}${argument.info.id}`;
-    graph.addVertex({ tag: 'use', id: argument.info.id, name: argumentName, environment: data.environments, when: 'always' });
+    const graph = value?.graph ?? new graph_1.DataflowGraph(data.completeAst.idMap);
+    const argumentName = argument.name?.content;
+    let entryPoint = value?.entryPoint;
+    if (argumentName) {
+        graph.addVertex({
+            tag: "use" /* VertexType.Use */,
+            id: argument.info.id,
+            controlDependencies: data.controlDependencies
+        });
+        entryPoint = argument.info.id;
+    }
     const ingoingRefs = [...value?.unknownReferences ?? [], ...value?.in ?? [], ...(name === undefined ? [] : [...name.in])];
-    if (argument.value?.type === "RFunctionDefinition" /* RType.FunctionDefinition */) {
-        graph.addEdge(argument.info.id, argument.value.info.id, graph_1.EdgeType.Reads, 'always');
+    if (entryPoint && argument.value?.type === "RFunctionDefinition" /* RType.FunctionDefinition */) {
+        graph.addEdge(entryPoint, argument.value.info.id, { type: 1 /* EdgeType.Reads */ });
     }
-    else {
+    else if (argumentName) {
         // we only need to link against those which are not already bound to another function call argument
         linkReadsForArgument(argument, [...ingoingRefs, ...value?.out ?? [] /* value may perform definitions */], graph);
     }
     return {
         unknownReferences: [],
         // active nodes of the name will be lost as they are only used to reference the corresponding parameter
-        in: ingoingRefs,
-        // , ...value.out, ...(name?.out ?? [])
-        out: [{ name: argumentName, scope: scopes_1.LocalScope, nodeId: argument.info.id, used: 'always' }],
+        in: ingoingRefs.filter(r => r.name !== undefined),
+        out: [...value?.out ?? [], ...(name?.out ?? [])],
         graph: graph,
-        environments: value?.environments ?? data.environments,
-        scope: data.activeScope
+        environment: value?.environment ?? data.environment,
+        entryPoint: entryPoint ?? argument.info.id,
+        exitPoints: value?.exitPoints ?? name?.exitPoints ?? [{ nodeId: argument.info.id, type: 0 /* ExitPointType.Default */, controlDependencies: data.controlDependencies }]
     };
 }
 exports.processFunctionArgument = processFunctionArgument;
-//# sourceMappingURL=argument.js.map
+//# sourceMappingURL=process-argument.js.map

package/dataflow/internal/process/functions/{parameter.d.ts → process-parameter.d.ts}

@@ -1,4 +1,5 @@
-import type { DataflowInformation } from '../../info';
+import type { DataflowInformation } from '../../../info';
 import type { DataflowProcessorInformation } from '../../../processor';
-import type { ParentInformation, RParameter } from '../../../../r-bridge';
+import type { RParameter } from '../../../../r-bridge/lang-4.x/ast/model/nodes/r-parameter';
+import type { ParentInformation } from '../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 export declare function processFunctionParameter<OtherInfo>(parameter: RParameter<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/functions/{parameter.js → process-parameter.js}

@@ -2,10 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processFunctionParameter = void 0;
 const processor_1 = require("../../../processor");
-const environments_1 = require("../../../environments");
 const log_1 = require("../../../../util/log");
-const graph_1 = require("../../../graph");
-const scopes_1 = require("../../../environments/scopes");
+const define_1 = require("../../../environments/define");
 function processFunctionParameter(parameter, data) {
     const name = (0, processor_1.processDataflowFor)(parameter.name, data);
     const defaultValue = parameter.defaultValue === undefined ? undefined : (0, processor_1.processDataflowFor)(parameter.defaultValue, data);
@@ -13,23 +11,21 @@ function processFunctionParameter(parameter, data) {
     const writtenNodes = name.unknownReferences.map(n => ({
         ...n,
         kind: 'parameter',
-        used: 'always',
-        definedAt: parameter.info.id,
-        scope: scopes_1.LocalScope
+        definedAt: parameter.info.id
     }));
-    let environments = name.environments;
+    let environment = name.environment;
     for (const writtenNode of writtenNodes) {
         log_1.log.trace(`parameter ${writtenNode.name} (${writtenNode.nodeId}) is defined at id ${writtenNode.definedAt} with ${defaultValue === undefined ? 'no default value' : ' no default value'}`);
         graph.setDefinitionOfVertex(writtenNode);
-        environments = (0, environments_1.define)(writtenNode, scopes_1.LocalScope, environments);
+        environment = (0, define_1.define)(writtenNode, false, environment);
         if (defaultValue !== undefined) {
             if (parameter.defaultValue?.type === "RFunctionDefinition" /* RType.FunctionDefinition */) {
-                graph.addEdge(writtenNode, parameter.defaultValue.info.id, graph_1.EdgeType.DefinedBy, 'maybe' /* default arguments can be overridden! */);
+                graph.addEdge(writtenNode, parameter.defaultValue.info.id, { type: 2 /* EdgeType.DefinedBy */ });
             }
             else {
                 const definedBy = [...defaultValue.in, ...defaultValue.unknownReferences];
                 for (const node of definedBy) {
-                    graph.addEdge(writtenNode, node, graph_1.EdgeType.DefinedBy, 'maybe' /* default arguments can be overridden! */);
+                    graph.addEdge(writtenNode, node, { type: 2 /* EdgeType.DefinedBy */ });
                 }
             }
         }
@@ -39,9 +35,10 @@ function processFunctionParameter(parameter, data) {
         in: defaultValue === undefined ? [] : [...defaultValue.in, ...defaultValue.unknownReferences, ...name.in],
         out: [...(defaultValue?.out ?? []), ...name.out, ...name.unknownReferences],
         graph: graph,
-        environments: environments,
-        scope: data.activeScope
+        environment: environment,
+        entryPoint: parameter.info.id,
+        exitPoints: [{ nodeId: parameter.info.id, type: 0 /* ExitPointType.Default */, controlDependencies: data.controlDependencies }]
     };
 }
 exports.processFunctionParameter = processFunctionParameter;
-//# sourceMappingURL=parameter.js.map
+//# sourceMappingURL=process-parameter.js.map

package/dataflow/internal/process/process-named-call.d.ts

@@ -0,0 +1,6 @@
+import type { DataflowProcessorInformation } from '../../processor';
+import type { DataflowInformation } from '../../info';
+import type { Base, RNode, Location } from '../../../r-bridge/lang-4.x/ast/model/model';
+import type { ParentInformation } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { EmptyArgument } from '../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+export declare function processAsNamedCall<OtherInfo>(functionName: RNode<OtherInfo & ParentInformation> & Base<OtherInfo> & Location, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, name: string, args: readonly (RNode<OtherInfo & ParentInformation> | typeof EmptyArgument | undefined)[]): DataflowInformation;

package/dataflow/internal/process/process-named-call.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processAsNamedCall = void 0;
+const named_call_handling_1 = require("./functions/call/named-call-handling");
+const make_argument_1 = require("./functions/call/argument/make-argument");
+function processAsNamedCall(functionName, data, name, args) {
+    return (0, named_call_handling_1.processNamedCall)({
+        type: "RSymbol" /* RType.Symbol */,
+        info: functionName.info,
+        content: name,
+        lexeme: functionName.lexeme,
+        location: functionName.location,
+        namespace: undefined
+    }, (0, make_argument_1.wrapArgumentsUnnamed)(args, data.completeAst.idMap), functionName.info.id, data);
+}
+exports.processAsNamedCall = processAsNamedCall;
+//# sourceMappingURL=process-named-call.js.map

package/dataflow/internal/process/process-symbol.d.ts

@@ -0,0 +1,5 @@
+import { type DataflowInformation } from '../../info';
+import type { DataflowProcessorInformation } from '../../processor';
+import type { RSymbol } from '../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
+import type { ParentInformation } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+export declare function processSymbol<OtherInfo>(symbol: RSymbol<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo>): DataflowInformation;

package/dataflow/internal/process/process-symbol.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processSymbol = void 0;
+const process_value_1 = require("./process-value");
+const convert_values_1 = require("../../../r-bridge/lang-4.x/convert-values");
+const graph_1 = require("../../graph/graph");
+function processSymbol(symbol, data) {
+    if (symbol.content === convert_values_1.RNull || symbol.content === convert_values_1.RNa) {
+        return (0, process_value_1.processValue)(symbol, data);
+    }
+    return {
+        unknownReferences: [{ nodeId: symbol.info.id, name: symbol.content, controlDependencies: data.controlDependencies }],
+        in: [],
+        out: [],
+        environment: data.environment,
+        graph: new graph_1.DataflowGraph(data.completeAst.idMap).addVertex({
+            tag: "use" /* VertexType.Use */,
+            id: symbol.info.id,
+            controlDependencies: data.controlDependencies
+        }),
+        entryPoint: symbol.info.id,
+        exitPoints: [{ nodeId: symbol.info.id, type: 0 /* ExitPointType.Default */, controlDependencies: data.controlDependencies }]
+    };
+}
+exports.processSymbol = processSymbol;
+//# sourceMappingURL=process-symbol.js.map

package/dataflow/internal/process/process-uninteresting-leaf.d.ts

@@ -0,0 +1,4 @@
+import { type DataflowInformation } from '../../info';
+import type { DataflowProcessorInformation } from '../../processor';
+import type { RNodeWithParent } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+export declare function processUninterestingLeaf<OtherInfo>(leaf: RNodeWithParent, info: DataflowProcessorInformation<OtherInfo>): DataflowInformation;

package/dataflow/internal/process/process-uninteresting-leaf.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processUninterestingLeaf = void 0;
+const info_1 = require("../../info");
+function processUninterestingLeaf(leaf, info) {
+    return (0, info_1.initializeCleanDataflowInformation)(leaf.info.id, info);
+}
+exports.processUninterestingLeaf = processUninterestingLeaf;
+//# sourceMappingURL=process-uninteresting-leaf.js.map

package/dataflow/internal/process/process-value.d.ts

@@ -0,0 +1,4 @@
+import { type DataflowInformation } from '../../info';
+import type { DataflowProcessorInformation } from '../../processor';
+import type { RNodeWithParent } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+export declare function processValue<OtherInfo>(value: RNodeWithParent, data: DataflowProcessorInformation<OtherInfo>): DataflowInformation;

package/dataflow/internal/process/process-value.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processValue = void 0;
+const graph_1 = require("../../graph/graph");
+function processValue(value, data) {
+    return {
+        unknownReferences: [],
+        in: [{ nodeId: value.info.id, name: undefined, controlDependencies: data.controlDependencies }],
+        out: [],
+        environment: data.environment,
+        graph: new graph_1.DataflowGraph(data.completeAst.idMap).addVertex({
+            tag: "value" /* VertexType.Value */,
+            id: value.info.id,
+            value: value.lexeme,
+            controlDependencies: data.controlDependencies
+        }),
+        exitPoints: [{ nodeId: value.info.id, type: 0 /* ExitPointType.Default */, controlDependencies: data.controlDependencies }],
+        entryPoint: value.info.id
+    };
+}
+exports.processValue = processValue;
+//# sourceMappingURL=process-value.js.map

package/dataflow/logger.d.ts

@@ -0,0 +1 @@
+export declare const dataflowLogger: import("tslog").Logger<import("tslog").ILogObj>;

package/dataflow/logger.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataflowLogger = void 0;
+const log_1 = require("../util/log");
+exports.dataflowLogger = log_1.log.getSubLogger({ name: 'dataflow' });
+//# sourceMappingURL=logger.js.map