@eagleoutice/flowr 2.0.25 → 2.1.0

package/dataflow/internal/linker.js

@@ -1,45 +1,68 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.linkCircularRedefinitionsWithinALoop = exports.linkInputs = exports.getAllLinkedFunctionDefinitions = exports.linkFunctionCalls = exports.linkFunctionCallWithSingleTarget = exports.linkArgumentsOnCall = exports.produceNameSharedIdMap = exports.findNonLocalReads = void 0;
+exports.findNonLocalReads = findNonLocalReads;
+exports.produceNameSharedIdMap = produceNameSharedIdMap;
+exports.linkArgumentsOnCall = linkArgumentsOnCall;
+exports.linkFunctionCallWithSingleTarget = linkFunctionCallWithSingleTarget;
+exports.linkFunctionCalls = linkFunctionCalls;
+exports.getAllFunctionCallTargets = getAllFunctionCallTargets;
+exports.getAllLinkedFunctionDefinitions = getAllLinkedFunctionDefinitions;
+exports.linkInputs = linkInputs;
+exports.linkCircularRedefinitionsWithinALoop = linkCircularRedefinitionsWithinALoop;
 const defaultmap_1 = require("../../util/defaultmap");
 const assert_1 = require("../../util/assert");
 const log_1 = require("../../util/log");
 const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
+const identifier_1 = require("../environments/identifier");
 const graph_1 = require("../graph/graph");
 const logger_1 = require("../logger");
 const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const edge_1 = require("../graph/edge");
+const type_1 = require("../../r-bridge/lang-4.x/ast/model/type");
+const vertex_1 = require("../graph/vertex");
 const resolve_by_name_1 = require("../environments/resolve-by-name");
 const built_in_1 = require("../environments/built-in");
 const static_slicer_1 = require("../../slicing/static/static-slicer");
-function findNonLocalReads(graph) {
+function findNonLocalReads(graph, ignore) {
+    const ignores = new Set(ignore.map(i => i.nodeId));
     const ids = new Set([...graph.vertices(true)]
-        .filter(([_, info]) => info.tag === "use" /* VertexType.Use */ || info.tag === "function-call" /* VertexType.FunctionCall */)
+        .filter(([_, info]) => info.tag === vertex_1.VertexType.Use || info.tag === vertex_1.VertexType.FunctionCall)
         .map(([id, _]) => id));
     /* find all variable use ids which do not link to a given id */
     const nonLocalReads = [];
     for (const id of ids) {
+        if (ignores.has(id)) {
+            continue;
+        }
         const outgoing = graph.outgoingEdges(id);
+        const name = (0, node_id_1.recoverName)(id, graph.idMap);
+        const origin = graph.getVertex(id, true);
         if (outgoing === undefined) {
+            nonLocalReads.push({
+                name: (0, node_id_1.recoverName)(id, graph.idMap),
+                nodeId: id,
+                controlDependencies: undefined,
+                type: origin?.tag === vertex_1.VertexType.FunctionCall ? identifier_1.ReferenceType.Function : identifier_1.ReferenceType.Variable
+            });
             continue;
         }
         for (const [target, { types }] of outgoing) {
-            if ((0, edge_1.edgeIncludesType)(types, 1 /* EdgeType.Reads */) && !ids.has(target)) {
-                const name = (0, node_id_1.recoverName)(id, graph.idMap);
+            if ((0, edge_1.edgeIncludesType)(types, edge_1.EdgeType.Reads) && !ids.has(target)) {
                 if (!name) {
                     logger_1.dataflowLogger.warn('found non-local read without name for id ' + id);
                 }
                 nonLocalReads.push({
                     name: (0, node_id_1.recoverName)(id, graph.idMap),
                     nodeId: id,
-                    controlDependencies: undefined
+                    controlDependencies: undefined,
+                    type: origin?.tag === vertex_1.VertexType.FunctionCall ? identifier_1.ReferenceType.Function : identifier_1.ReferenceType.Variable
                 });
+                break;
             }
         }
     }
     return nonLocalReads;
 }
-exports.findNonLocalReads = findNonLocalReads;
 function produceNameSharedIdMap(references) {
     const nameIdShares = new defaultmap_1.DefaultMap(() => []);
     for (const reference of references) {
@@ -49,7 +72,6 @@ function produceNameSharedIdMap(references) {
     }
     return nameIdShares;
 }
-exports.produceNameSharedIdMap = produceNameSharedIdMap;
 function linkArgumentsOnCall(args, params, graph) {
     const nameArgMap = new Map(args.filter(graph_1.isNamedArgument).map(a => [a.name, a]));
     const nameParamMap = new Map(params.map(p => [p.name.content, p]));
@@ -61,12 +83,12 @@ function linkArgumentsOnCall(args, params, graph) {
         const param = nameParamMap.get(name);
         if (param !== undefined) {
             logger_1.dataflowLogger.trace(`mapping named argument "${name}" to parameter "${param.name.content}"`);
-            graph.addEdge(arg.nodeId, param.name.info.id, { type: 16 /* EdgeType.DefinesOnCall */ });
+            graph.addEdge(arg.nodeId, param.name.info.id, edge_1.EdgeType.DefinesOnCall);
             matchedParameters.add(name);
         }
         else if (specialDotParameter !== undefined) {
             logger_1.dataflowLogger.trace(`mapping named argument "${name}" to dot-dot-dot parameter`);
-            graph.addEdge(arg.nodeId, specialDotParameter.name.info.id, { type: 16 /* EdgeType.DefinesOnCall */ });
+            graph.addEdge(arg.nodeId, specialDotParameter.name.info.id, edge_1.EdgeType.DefinesOnCall);
         }
     }
     const remainingParameter = params.filter(p => !matchedParameters.has(p.name.content));
@@ -80,7 +102,7 @@ function linkArgumentsOnCall(args, params, graph) {
         if (remainingParameter.length <= i) {
             if (specialDotParameter !== undefined) {
                 logger_1.dataflowLogger.trace(`mapping unnamed argument ${i} (id: ${arg.nodeId}) to dot-dot-dot parameter`);
-                graph.addEdge(arg.nodeId, specialDotParameter.name.info.id, { type: 16 /* EdgeType.DefinesOnCall */ });
+                graph.addEdge(arg.nodeId, specialDotParameter.name.info.id, edge_1.EdgeType.DefinesOnCall);
             }
             else {
                 logger_1.dataflowLogger.warn(`skipping argument ${i} as there is no corresponding parameter - R should block that`);
@@ -89,10 +111,9 @@ function linkArgumentsOnCall(args, params, graph) {
         }
         const param = remainingParameter[i];
         logger_1.dataflowLogger.trace(`mapping unnamed argument ${i} (id: ${arg.nodeId}) to parameter "${param.name.content}"`);
-        graph.addEdge(arg.nodeId, param.name.info.id, { type: 16 /* EdgeType.DefinesOnCall */ });
+        graph.addEdge(arg.nodeId, param.name.info.id, edge_1.EdgeType.DefinesOnCall);
     }
 }
-exports.linkArgumentsOnCall = linkArgumentsOnCall;
 function linkFunctionCallArguments(targetId, idMap, functionCallName, functionRootId, callArgs, finalGraph) {
     // we get them by just choosing the rhs of the definition
     const linkedFunction = idMap.get(targetId);
@@ -100,7 +121,7 @@ function linkFunctionCallArguments(targetId, idMap, functionCallName, functionRo
         logger_1.dataflowLogger.trace(`no function definition found for ${functionCallName} (${functionRootId})`);
         return;
     }
-    if (linkedFunction.type !== "RFunctionDefinition" /* RType.FunctionDefinition */) {
+    if (linkedFunction.type !== type_1.RType.FunctionDefinition) {
         logger_1.dataflowLogger.trace(`function call definition base ${functionCallName} does not lead to a function definition (${functionRootId}) but got ${linkedFunction.type}`);
         return;
     }
@@ -112,37 +133,37 @@ function linkFunctionCallWithSingleTarget(graph, def, info, idMap) {
     if (info.environment !== undefined) {
         // for each open ingoing reference, try to resolve it here, and if so, add a read edge from the call to signal that it reads it
         for (const ingoing of def.subflow.in) {
-            const defs = ingoing.name ? (0, resolve_by_name_1.resolveByName)(ingoing.name, info.environment) : undefined;
+            const defs = ingoing.name ? (0, resolve_by_name_1.resolveByName)(ingoing.name, info.environment, ingoing.type) : undefined;
             if (defs === undefined) {
                 continue;
             }
             for (const def of defs) {
-                graph.addEdge(id, def, { type: 1 /* EdgeType.Reads */ });
+                graph.addEdge(id, def, edge_1.EdgeType.Reads);
             }
         }
     }
     const exitPoints = def.exitPoints;
     for (const exitPoint of exitPoints) {
-        graph.addEdge(id, exitPoint, { type: 8 /* EdgeType.Returns */ });
+        graph.addEdge(id, exitPoint, edge_1.EdgeType.Returns);
     }
     const defName = (0, node_id_1.recoverName)(def.id, idMap);
     (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `recording expression-list-level call from ${(0, node_id_1.recoverName)(info.id, idMap)} to ${defName}`);
-    graph.addEdge(id, def.id, { type: 4 /* EdgeType.Calls */ });
+    graph.addEdge(id, def.id, edge_1.EdgeType.Calls);
     linkFunctionCallArguments(def.id, idMap, defName, id, info.args, graph);
 }
-exports.linkFunctionCallWithSingleTarget = linkFunctionCallWithSingleTarget;
+/* there is _a lot_ potential for optimization here */
 function linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefinitions) {
     const edges = graph.outgoingEdges(id);
     if (edges === undefined) {
         /* no outgoing edges */
         return;
     }
-    const readBits = 1 /* EdgeType.Reads */ | 4 /* EdgeType.Calls */;
-    const functionDefinitionReadIds = [...edges].filter(([_, e]) => (0, edge_1.edgeDoesNotIncludeType)(e.types, 64 /* EdgeType.Argument */)
+    const readBits = edge_1.EdgeType.Reads | edge_1.EdgeType.Calls;
+    const functionDefinitionReadIds = [...edges].filter(([_, e]) => (0, edge_1.edgeDoesNotIncludeType)(e.types, edge_1.EdgeType.Argument)
         && (0, edge_1.edgeIncludesType)(e.types, readBits)).map(([target, _]) => target);
     const functionDefs = getAllLinkedFunctionDefinitions(new Set(functionDefinitionReadIds), graph);
     for (const def of functionDefs.values()) {
-        (0, assert_1.guard)(def.tag === "function-definition" /* VertexType.FunctionDefinition */, () => `expected function definition, but got ${def.tag}`);
+        (0, assert_1.guard)(def.tag === vertex_1.VertexType.FunctionDefinition, () => `expected function definition, but got ${def.tag}`);
         linkFunctionCallWithSingleTarget(graph, def, info, idMap);
     }
     if (thisGraph.isRoot(id)) {
@@ -159,14 +180,41 @@ function linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefin
  */
 function linkFunctionCalls(graph, idMap, thisGraph) {
     const functionCalls = [...thisGraph.vertices(true)]
-        .filter(([_, info]) => info.tag === "function-call" /* VertexType.FunctionCall */);
+        .filter(([_, info]) => info.tag === vertex_1.VertexType.FunctionCall);
     const calledFunctionDefinitions = [];
     for (const [id, info] of functionCalls) {
         linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefinitions);
     }
     return calledFunctionDefinitions;
 }
-exports.linkFunctionCalls = linkFunctionCalls;
+/** convenience function returning all known call targets */
+function getAllFunctionCallTargets(call, graph) {
+    const found = [];
+    const callVertex = graph.get(call, true);
+    if (callVertex === undefined) {
+        return [];
+    }
+    const [info, outgoingEdges] = callVertex;
+    if (info.tag !== vertex_1.VertexType.FunctionCall) {
+        return [];
+    }
+    if (info.name !== undefined && info.environment !== undefined) {
+        const functionCallDefs = (0, resolve_by_name_1.resolveByName)(info.name, info.environment, identifier_1.ReferenceType.Function)?.map(d => d.nodeId) ?? [];
+        for (const [target, outgoingEdge] of outgoingEdges.entries()) {
+            if ((0, edge_1.edgeIncludesType)(outgoingEdge.types, edge_1.EdgeType.Calls)) {
+                functionCallDefs.push(target);
+            }
+        }
+        const functionCallTargets = getAllLinkedFunctionDefinitions(new Set(functionCallDefs), graph);
+        for (const target of functionCallTargets) {
+            found.push(target.id);
+        }
+        for (const def of functionCallDefs) {
+            found.push(def);
+        }
+    }
+    return found;
+}
 function getAllLinkedFunctionDefinitions(functionDefinitionReadIds, dataflowGraph) {
     const potential = [...functionDefinitionReadIds];
     const visited = new Set();
@@ -184,13 +232,13 @@ function getAllLinkedFunctionDefinitions(functionDefinitionReadIds, dataflowGrap
         }
         visited.add(currentId);
         const outgoingEdges = [...currentInfo[1]];
-        const returnEdges = outgoingEdges.filter(([_, e]) => (0, edge_1.edgeIncludesType)(e.types, 8 /* EdgeType.Returns */));
+        const returnEdges = outgoingEdges.filter(([_, e]) => (0, edge_1.edgeIncludesType)(e.types, edge_1.EdgeType.Returns));
         if (returnEdges.length > 0) {
             // only traverse return edges and do not follow `calls` etc. as this indicates that we have a function call which returns a result, and not the function calls itself
             potential.push(...returnEdges.map(([target]) => target).filter(id => !visited.has(id)));
             continue;
         }
-        const followBits = 1 /* EdgeType.Reads */ | 2 /* EdgeType.DefinedBy */ | 32 /* EdgeType.DefinedByOnCall */;
+        const followBits = edge_1.EdgeType.Reads | edge_1.EdgeType.DefinedBy | edge_1.EdgeType.DefinedByOnCall;
         const followEdges = outgoingEdges.filter(([_, e]) => (0, edge_1.edgeIncludesType)(e.types, followBits));
         if (currentInfo[0].subflow !== undefined) {
             result.add(currentInfo[0]);
@@ -200,7 +248,6 @@ function getAllLinkedFunctionDefinitions(functionDefinitionReadIds, dataflowGrap
     }
     return result;
 }
-exports.getAllLinkedFunctionDefinitions = getAllLinkedFunctionDefinitions;
 /**
  * This method links a set of read variables to definitions in an environment.
  *
@@ -214,7 +261,7 @@ exports.getAllLinkedFunctionDefinitions = getAllLinkedFunctionDefinitions;
  */
 function linkInputs(referencesToLinkAgainstEnvironment, environmentInformation, givenInputs, graph, maybeForRemaining) {
     for (const bodyInput of referencesToLinkAgainstEnvironment) {
-        const probableTarget = bodyInput.name ? (0, resolve_by_name_1.resolveByName)(bodyInput.name, environmentInformation) : undefined;
+        const probableTarget = bodyInput.name ? (0, resolve_by_name_1.resolveByName)(bodyInput.name, environmentInformation, bodyInput.type) : undefined;
         if (probableTarget === undefined) {
             log_1.log.trace(`found no target for ${bodyInput.name}`);
             if (maybeForRemaining) {
@@ -225,14 +272,13 @@ function linkInputs(referencesToLinkAgainstEnvironment, environmentInformation,
         else {
             for (const target of probableTarget) {
                 // we can stick with maybe even if readId.attribute is always
-                graph.addEdge(bodyInput, target, { type: 1 /* EdgeType.Reads */ });
+                graph.addEdge(bodyInput, target, edge_1.EdgeType.Reads);
             }
         }
     }
     // data.graph.get(node.id).definedAtPosition = false
     return givenInputs;
 }
-exports.linkInputs = linkInputs;
 /** all loops variables which are open read (not already bound by a redefinition within the loop) get a maybe read marker to their last definition within the loop
  * e.g. with:
  * ```R
@@ -255,11 +301,10 @@ function linkCircularRedefinitionsWithinALoop(graph, openIns, outgoing) {
         for (const out of lastOutgoing.values()) {
             if (out.name === name) {
                 for (const target of targets) {
-                    graph.addEdge(target.nodeId, out.nodeId, { type: 1 /* EdgeType.Reads */ });
+                    graph.addEdge(target.nodeId, out.nodeId, edge_1.EdgeType.Reads);
                 }
             }
         }
     }
 }
-exports.linkCircularRedefinitionsWithinALoop = linkCircularRedefinitionsWithinALoop;
 //# sourceMappingURL=linker.js.map

package/dataflow/internal/process/functions/call/argument/make-argument.js

@@ -1,15 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrapArgumentsUnnamed = exports.toUnnamedArgument = void 0;
+exports.toUnnamedArgument = toUnnamedArgument;
+exports.wrapArgumentsUnnamed = wrapArgumentsUnnamed;
 const range_1 = require("../../../../../../util/range");
 const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
 const voidRange = (0, range_1.rangeFrom)(-1, -1, -1, -1);
 function toUnnamedArgument(node, idMap) {
     if (node === undefined) {
         return r_function_call_1.EmptyArgument;
     }
     const arg = {
-        type: "RArgument" /* RType.Argument */,
+        type: type_1.RType.Argument,
         lexeme: node.lexeme ?? '',
         // is this correct?
         location: node.location ?? voidRange,
@@ -23,9 +25,7 @@ function toUnnamedArgument(node, idMap) {
     idMap.set(arg.info.id, node);
     return arg;
 }
-exports.toUnnamedArgument = toUnnamedArgument;
 function wrapArgumentsUnnamed(nodes, idMap) {
-    return nodes.map(n => n === r_function_call_1.EmptyArgument || n?.type === "RArgument" /* RType.Argument */ ? n : toUnnamedArgument(n, idMap));
+    return nodes.map(n => n === r_function_call_1.EmptyArgument || n?.type === type_1.RType.Argument ? n : toUnnamedArgument(n, idMap));
 }
-exports.wrapArgumentsUnnamed = wrapArgumentsUnnamed;
 //# sourceMappingURL=make-argument.js.map

package/dataflow/internal/process/functions/call/argument/unpack-argument.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unpackArgument = void 0;
+exports.unpackArgument = unpackArgument;
 const log_1 = require("../../../../../../util/log");
 const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 function unpackArgument(arg) {
@@ -14,5 +14,4 @@ function unpackArgument(arg) {
     }
     return arg.value;
 }
-exports.unpackArgument = unpackArgument;
 //# sourceMappingURL=unpack-argument.js.map

package/dataflow/internal/process/functions/call/built-in/built-in-access.js

@@ -1,13 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processAccess = void 0;
+exports.processAccess = processAccess;
 const assert_1 = require("../../../../../../util/assert");
 const known_call_handling_1 = require("../known-call-handling");
 const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const logger_1 = require("../../../../../logger");
+const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
+const edge_1 = require("../../../../../graph/edge");
 const environment_1 = require("../../../../../environments/environment");
 const built_in_1 = require("../../../../../environments/built-in");
 const built_in_assignment_1 = require("./built-in-assignment");
+const identifier_1 = require("../../../../../environments/identifier");
 function tableAssignmentProcessor(name, args, rootId, data, outInfo) {
     outInfo.definitionRootNodes.push(rootId);
     return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
@@ -26,7 +29,7 @@ function processAccess(name, args, rootId, data, config) {
         const existing = data.environment.current.memory.get(':=');
         const outInfo = { definitionRootNodes: [] };
         data.environment.current.memory.set(':=', [{
-                kind: 'built-in-function',
+                type: identifier_1.ReferenceType.BuiltInFunction,
                 definedAt: built_in_1.BuiltIn,
                 controlDependencies: undefined,
                 processor: (name, args, rootId, data) => tableAssignmentProcessor(name, args, rootId, data, outInfo),
@@ -39,7 +42,7 @@ function processAccess(name, args, rootId, data, config) {
             data.environment.current.memory.set(':=', existing);
         }
         if (head.value && outInfo.definitionRootNodes.length > 0) {
-            (0, built_in_assignment_1.markAsAssignment)(fnCall.information, { kind: 'variable', name: head.value.lexeme ?? '', nodeId: head.value.info.id, definedAt: rootId, controlDependencies: [] }, outInfo.definitionRootNodes, rootId);
+            (0, built_in_assignment_1.markAsAssignment)(fnCall.information, { type: identifier_1.ReferenceType.Variable, name: head.value.lexeme ?? '', nodeId: head.value.info.id, definedAt: rootId, controlDependencies: [] }, outInfo.definitionRootNodes, rootId);
         }
     }
     else {
@@ -47,11 +50,11 @@ function processAccess(name, args, rootId, data, config) {
         // if the argument is a symbol, we convert it to a string for this perspective
         for (let i = 1; i < newArgs.length; i++) {
             const arg = newArgs[i];
-            if (arg !== r_function_call_1.EmptyArgument && arg.value?.type === "RSymbol" /* RType.Symbol */) {
+            if (arg !== r_function_call_1.EmptyArgument && arg.value?.type === type_1.RType.Symbol) {
                 newArgs[i] = {
                     ...arg,
                     value: {
-                        type: "RString" /* RType.String */,
+                        type: type_1.RType.String,
                         info: arg.value.info,
                         lexeme: arg.value.lexeme,
                         location: arg.value.location,
@@ -66,11 +69,11 @@ function processAccess(name, args, rootId, data, config) {
         fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args: newArgs, rootId, data, forceArgs: config.forceArgs });
     }
     const info = fnCall.information;
-    info.graph.addEdge(name.info.id, fnCall.processedArguments[0]?.entryPoint ?? head.info.id, { type: 8 /* EdgeType.Returns */ });
+    info.graph.addEdge(name.info.id, fnCall.processedArguments[0]?.entryPoint ?? head.info.id, edge_1.EdgeType.Returns);
     /* access always reads all of its indices */
     for (const arg of fnCall.processedArguments) {
         if (arg !== undefined) {
-            info.graph.addEdge(name.info.id, arg.entryPoint, { type: 1 /* EdgeType.Reads */ });
+            info.graph.addEdge(name.info.id, arg.entryPoint, edge_1.EdgeType.Reads);
         }
         /* we include the read edges to the constant arguments as well so that they are included if necessary */
     }
@@ -100,5 +103,4 @@ function processAccess(name, args, rootId, data, config) {
         })
     };
 }
-exports.processAccess = processAccess;
 //# sourceMappingURL=built-in-access.js.map

package/dataflow/internal/process/functions/call/built-in/built-in-apply.d.ts

@@ -10,5 +10,9 @@ export interface BuiltInApplyConfiguration extends MergeableRecord {
     readonly indexOfFunction?: number;
     /** does the argument have a name that it can be given by as well? */
     readonly nameOfFunctionArgument?: string;
+    /**
+     * Should we unquote the function if it is given as a string?
+     */
+    readonly unquoteFunction?: boolean;
 }
-export declare function processApply<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, { indexOfFunction, nameOfFunctionArgument }: BuiltInApplyConfiguration): DataflowInformation;
+export declare function processApply<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, { indexOfFunction, nameOfFunctionArgument, unquoteFunction }: BuiltInApplyConfiguration): DataflowInformation;

package/dataflow/internal/process/functions/call/built-in/built-in-apply.js

@@ -1,10 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processApply = void 0;
+exports.processApply = processApply;
 const known_call_handling_1 = require("../known-call-handling");
 const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const logger_1 = require("../../../../../logger");
-function processApply(name, args, rootId, data, { indexOfFunction = 1, nameOfFunctionArgument }) {
+const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
+const vertex_1 = require("../../../../../graph/vertex");
+const edge_1 = require("../../../../../graph/edge");
+const identifier_1 = require("../../../../../environments/identifier");
+function processApply(name, args, rootId, data, { indexOfFunction = 1, nameOfFunctionArgument, unquoteFunction }) {
     /* as the length is one-based and the argument filter mapping is zero-based, we do not have to subtract 1 */
     const forceArgsMask = new Array(indexOfFunction).fill(false);
     forceArgsMask.push(true);
@@ -25,17 +29,32 @@ function processApply(name, args, rootId, data, { indexOfFunction = 1, nameOfFun
         return information;
     }
     const arg = args[index];
-    if (arg === r_function_call_1.EmptyArgument || arg?.value?.type !== "RSymbol" /* RType.Symbol */) {
+    if (arg === r_function_call_1.EmptyArgument || !arg.value || (!unquoteFunction && arg.value.type !== type_1.RType.Symbol)) {
         logger_1.dataflowLogger.warn(`Expected symbol as argument at index ${index}, but got ${JSON.stringify(arg)} instead.`);
         return information;
     }
-    const functionSymbol = arg.value;
+    let functionId;
+    let functionName;
+    const val = arg.value;
+    if (unquoteFunction && val.type === type_1.RType.String) {
+        functionId = val.info.id;
+        functionName = val.content.str;
+    }
+    else if (val.type === type_1.RType.Symbol) {
+        functionId = val.info.id;
+        functionName = val.content;
+    }
+    else {
+        logger_1.dataflowLogger.warn(`Expected symbol or string as function argument at index ${index}, but got ${JSON.stringify(val)} instead.`);
+        return information;
+    }
     const allOtherArguments = processedArguments.filter((_, i) => i !== index).map((arg, i) => {
         const counterpart = args[i];
         if (arg && counterpart !== r_function_call_1.EmptyArgument && counterpart.name) {
             return {
                 name: counterpart.name.content,
                 controlDependencies: data.controlDependencies,
+                type: identifier_1.ReferenceType.Argument,
                 nodeId: arg.entryPoint
             };
         }
@@ -43,12 +62,11 @@ function processApply(name, args, rootId, data, { indexOfFunction = 1, nameOfFun
             return r_function_call_1.EmptyArgument;
         }
     });
-    const applyCallId = functionSymbol.info.id;
     /* identify it as a full-blown function call :) */
     information.graph.updateToFunctionCall({
-        tag: "function-call" /* VertexType.FunctionCall */,
-        id: applyCallId,
-        name: functionSymbol.content,
+        tag: vertex_1.VertexType.FunctionCall,
+        id: functionId,
+        name: functionName,
         args: allOtherArguments,
         environment: data.environment,
         onlyBuiltin: false,
@@ -56,10 +74,9 @@ function processApply(name, args, rootId, data, { indexOfFunction = 1, nameOfFun
     });
     for (const arg of processedArguments) {
         if (arg) {
-            information.graph.addEdge(applyCallId, arg.entryPoint, { type: 64 /* EdgeType.Argument */ });
+            information.graph.addEdge(functionId, arg.entryPoint, edge_1.EdgeType.Argument);
         }
     }
     return information;
 }
-exports.processApply = processApply;
 //# sourceMappingURL=built-in-apply.js.map