@eagleoutice/flowr 2.0.20 → 2.0.22

package/dataflow/environments/built-in.js

@@ -109,9 +109,10 @@ registerBuiltInConstant(true, 'T', true);
 registerBuiltInConstant(true, 'FALSE', false);
 registerBuiltInConstant(true, 'F', false);
 registerSimpleFunctions('~', '+', '-', '*', '/', '^', '!', '?', '**', '==', '!=', '>', '<', '>=', '<=', '%%', '%/%', '%*%', '%in%', ':', 'list', 'c', 'rep', 'seq', 'seq_len', 'seq_along', 'seq.int', 'gsub', 'which', 'class', 'dimnames', 'min', 'max', 'intersect', 'subset', 'match', 'sqrt', 'abs', 'round', 'floor', 'ceiling', 'signif', 'trunc', 'log', 'log10', 'log2', 'sum', 'mean', 'unique', 'paste', 'paste0', 'read.csv', 'stop', 'is.null', 'plot', 'numeric', 'as.character', 'as.integer', 'as.logical', 'as.numeric', 'as.matrix', 'do.call', 'rbind', 'nrow', 'ncol', 'tryCatch', 'expression', 'factor', 'missing', 'as.data.frame', 'data.frame', 'na.omit', 'rownames', 'names', 'order', 'length', 'any', 'dim', 'matrix', 'cbind', 'nchar', 't');
-registerBuiltInFunctions(false, ['lapply', 'sapply', 'vapply', 'mapply'], built_in_apply_1.processApply, { indexOfFunction: 1, nameOfFunctionArgument: 'FUN' });
+registerBuiltInFunctions(false, ['mapply', 'Mapply'], built_in_apply_1.processApply, { indexOfFunction: 0, nameOfFunctionArgument: 'FUN' });
+registerBuiltInFunctions(false, ['lapply', 'sapply', 'vapply'], built_in_apply_1.processApply, { indexOfFunction: 1, nameOfFunctionArgument: 'FUN' });
 /* functool wrappers */
-registerBuiltInFunctions(false, ['Lapply', 'Sapply', 'Vapply', 'Mapply'], built_in_apply_1.processApply, { indexOfFunction: 1, nameOfFunctionArgument: 'FUN' });
+registerBuiltInFunctions(false, ['Lapply', 'Sapply', 'Vapply'], built_in_apply_1.processApply, { indexOfFunction: 1, nameOfFunctionArgument: 'FUN' });
 registerBuiltInFunctions(false, ['apply', 'tapply', 'Tapply'], built_in_apply_1.processApply, { indexOfFunction: 2, nameOfFunctionArgument: 'FUN' });
 registerBuiltInFunctions(false, ['print'], defaultBuiltInProcessor, { returnsNthArgument: 0, forceArgs: 'all' });
 registerBuiltInFunctions(true, ['('], defaultBuiltInProcessor, { returnsNthArgument: 0 });
@@ -143,7 +144,7 @@ registerBuiltInFunctions(true, ['for'], built_in_for_loop_1.processForLoop, {});
 registerBuiltInFunctions(true, ['repeat'], built_in_repeat_loop_1.processRepeatLoop, {});
 registerBuiltInFunctions(true, ['while'], built_in_while_loop_1.processWhileLoop, {});
 registerBuiltInFunctions(false, ['options'], defaultBuiltInProcessor, { hasUnknownSideEffects: true, forceArgs: 'all' });
-registerBuiltInFunctions(false, ['on.exit', 'sys.on.exit'], defaultBuiltInProcessor, { hasUnknownSideEffects: true });
+registerBuiltInFunctions(false, ['on.exit', 'sys.on.exit', 'par'], defaultBuiltInProcessor, { hasUnknownSideEffects: true });
 /* library and require is handled above */
 registerBuiltInFunctions(false, ['requireNamespace', 'loadNamespace', 'attachNamespace', 'asNamespace'], defaultBuiltInProcessor, { hasUnknownSideEffects: true });
 /* downloader and installer functions (R, devtools, BiocManager) */

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

@@ -25,6 +25,18 @@ function toReplacementSymbol(target, prefix, superAssignment) {
 function getEffectiveOrder(config, args) {
     return config.swapSourceAndTarget ? [args[1], args[0]] : args;
 }
+function findRootAccess(node) {
+    let current = node;
+    while (current.type === "RAccess" /* RType.Access */) {
+        current = current.accessed;
+    }
+    if (current.type === "RSymbol" /* RType.Symbol */) {
+        return current;
+    }
+    else {
+        return undefined;
+    }
+}
 /**
  * Processes an assignment, i.e., `<target> <- <source>`.
  * Handling it as a function call \`&lt;-\` `(<target>, <source>)`.
@@ -64,6 +76,29 @@ args, rootId, data, config) {
         const replacement = toReplacementSymbol(target, target.operator, config.superAssignment ?? false);
         return (0, process_named_call_1.processAsNamedCall)(replacement, data, replacement.content, [(0, make_argument_1.toUnnamedArgument)(target.accessed, data.completeAst.idMap), ...target.access, source]);
     }
+    else if (type === "RAccess" /* RType.Access */) {
+        const rootArg = findRootAccess(target);
+        if (rootArg) {
+            const res = (0, known_call_handling_1.processKnownFunctionCall)({
+                name,
+                args: [rootArg, source],
+                rootId,
+                data,
+                reverseOrder: !config.swapSourceAndTarget,
+                forceArgs: config.forceArgs
+            });
+            return processAssignmentToSymbol({
+                ...config,
+                nameOfAssignmentFunction: name.content,
+                source,
+                target: rootArg,
+                args: getEffectiveOrder(config, res.processedArguments),
+                rootId,
+                data,
+                information: res.information,
+            });
+        }
+    }
     else if (type === "RString" /* RType.String */) {
         return processAssignmentToString(target, args, name, rootId, data, config, source);
     }
@@ -79,7 +114,7 @@ function extractSourceAndTarget(args, name) {
     return { source, target };
 }
 function produceWrittenNodes(rootId, target, isFunctionDef, data, makeMaybe) {
-    return target.in.map(ref => ({
+    return [...target.in, ...target.unknownReferences].map(ref => ({
         ...ref,
         kind: isFunctionDef ? 'function' : 'variable',
         definedAt: rootId,

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

@@ -63,7 +63,7 @@ function processForLoop(name, args, rootId, data) {
     return {
         unknownReferences: [],
         // we only want those not bound by a local variable
-        in: [{ nodeId: rootId, name: name.content, controlDependencies: originalDependency }, ...variable.in, ...[...nameIdShares.values()].flat()],
+        in: [{ nodeId: rootId, name: name.content, controlDependencies: originalDependency }, ...variable.in, ...vector.in, ...vector.unknownReferences, ...[...nameIdShares.values()].flat()],
         out: outgoing,
         graph: nextGraph,
         entryPoint: name.info.id,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/flowr",
-  "version": "2.0.20",
+  "version": "2.0.22",
   "description": "Static Dataflow Analyzer and Program Slicer for the R Programming Language",
   "types": "dist/src/index.d.ts",
   "repository": {

package/r-bridge/lang-4.x/ast/model/processing/decorate.d.ts

@@ -44,11 +44,11 @@ export declare function deterministicLocationIdGenerator<OtherInfo>(start?: numb
 export interface ParentContextInfo extends MergeableRecord {
     role: RoleInParent;
     /**
-     * The depth of the node in the AST
+     * The nesting of the node in the AST
      *
-     * The root node has a depth of 0, its children a depth of 1, and so on.
+     * The root node has a nesting of 0, nested function calls, loops etc. will increase the nesting
      */
-    depth: number;
+    nesting: number;
     /**
      * 0-based index of the child in the parent (code semantics, e.g., for an if-then-else, the condition will be 0, the then-case will be 1, ...)
      *

package/r-bridge/lang-4.x/ast/model/processing/decorate.js

@@ -60,6 +60,9 @@ const defaultParentContext = {
     role: "root" /* RoleInParent.Root */,
     index: 0
 };
+const nestForElement = new Set([
+    "RFunctionDefinition" /* RType.FunctionDefinition */, "RForLoop" /* RType.ForLoop */, "RWhileLoop" /* RType.WhileLoop */, "RRepeatLoop" /* RType.RepeatLoop */, "RIfThenElse" /* RType.IfThenElse */,
+]);
 /**
  * Covert the given AST into a doubly linked tree while assigning ids (so it stays serializable).
  *
@@ -77,9 +80,16 @@ function decorateAst(ast, getId = deterministicCountingIdGenerator(0)) {
     const foldLeaf = createFoldForLeaf(info);
     const foldBinaryOp = createFoldForBinaryOp(info);
     const unaryOp = createFoldForUnaryOp(info);
-    /* we pass down the depth */
-    const decoratedAst = (0, stateful_fold_1.foldAstStateful)(ast, -1, {
-        down: (_, down) => down + 1,
+    /* we pass down the nesting depth */
+    const decoratedAst = (0, stateful_fold_1.foldAstStateful)(ast, 0, {
+        down: (n, nesting) => {
+            if (nestForElement.has(n.type)) {
+                return nesting + 1;
+            }
+            else {
+                return nesting;
+            }
+        },
         foldNumber: foldLeaf,
         foldString: foldLeaf,
         foldLogical: foldLeaf,
@@ -117,7 +127,7 @@ function decorateAst(ast, getId = deterministicCountingIdGenerator(0)) {
 }
 exports.decorateAst = decorateAst;
 function createFoldForLeaf(info) {
-    return (data, depth) => {
+    return (data, nesting) => {
         const id = info.getId(data);
         const decorated = {
             ...data,
@@ -126,7 +136,7 @@ function createFoldForLeaf(info) {
                 id,
                 parent: undefined,
                 ...defaultParentContext,
-                depth
+                nesting
             }
         };
         info.idMap.set(id, decorated);
@@ -134,9 +144,9 @@ function createFoldForLeaf(info) {
     };
 }
 function createFoldForBinaryOp(info) {
-    return (data, lhs, rhs, depth) => {
+    return (data, lhs, rhs, nesting) => {
         const id = info.getId(data);
-        const decorated = { ...data, info: { ...data.info, id, parent: undefined, depth }, lhs, rhs };
+        const decorated = { ...data, info: { ...data.info, id, parent: undefined, nesting }, lhs, rhs };
         info.idMap.set(id, decorated);
         const lhsInfo = lhs.info;
         lhsInfo.parent = id;
@@ -155,9 +165,9 @@ function createFoldForBinaryOp(info) {
     };
 }
 function createFoldForUnaryOp(info) {
-    return (data, operand, depth) => {
+    return (data, operand, nesting) => {
         const id = info.getId(data);
-        const decorated = { ...data, info: { ...data.info, id, parent: undefined, depth }, operand };
+        const decorated = { ...data, info: { ...data.info, id, parent: undefined, nesting }, operand };
         info.idMap.set(id, decorated);
         const opInfo = operand.info;
         opInfo.parent = id;
@@ -166,9 +176,9 @@ function createFoldForUnaryOp(info) {
     };
 }
 function createFoldForAccess(info) {
-    return (data, accessed, access, depth) => {
+    return (data, accessed, access, nesting) => {
         const id = info.getId(data);
-        const decorated = { ...data, info: { ...data.info, id, parent: undefined, depth }, accessed, access };
+        const decorated = { ...data, info: { ...data.info, id, parent: undefined, nesting }, accessed, access };
         info.idMap.set(id, decorated);
         const accessedInfo = accessed.info;
         accessedInfo.parent = id;
@@ -189,9 +199,9 @@ function createFoldForAccess(info) {
     };
 }
 function createFoldForForLoop(info) {
-    return (data, variable, vector, body, depth) => {
+    return (data, variable, vector, body, nesting) => {
         const id = info.getId(data);
-        const decorated = { ...data, info: { ...data.info, id, parent: undefined, depth }, variable, vector, body };
+        const decorated = { ...data, info: { ...data.info, id, parent: undefined, nesting }, variable, vector, body };
         info.idMap.set(id, decorated);
         const varInfo = variable.info;
         varInfo.parent = id;
@@ -208,9 +218,9 @@ function createFoldForForLoop(info) {
     };
 }
 function createFoldForRepeatLoop(info) {
-    return (data, body, depth) => {
+    return (data, body, nesting) => {
         const id = info.getId(data);
-        const decorated = { ...data, info: { ...data.info, id, parent: undefined, depth }, body };
+        const decorated = { ...data, info: { ...data.info, id, parent: undefined, nesting }, body };
         info.idMap.set(id, decorated);
         const bodyInfo = body.info;
         bodyInfo.parent = id;
@@ -219,9 +229,9 @@ function createFoldForRepeatLoop(info) {
     };
 }
 function createFoldForWhileLoop(info) {
-    return (data, condition, body, depth) => {
+    return (data, condition, body, nesting) => {
         const id = info.getId(data);
-        const decorated = { ...data, info: { ...data.info, id, parent: undefined, depth }, condition, body };
+        const decorated = { ...data, info: { ...data.info, id, parent: undefined, nesting }, condition, body };
         info.idMap.set(id, decorated);
         const condInfo = condition.info;
         condInfo.parent = id;
@@ -234,9 +244,9 @@ function createFoldForWhileLoop(info) {
     };
 }
 function createFoldForIfThenElse(info) {
-    return (data, condition, then, otherwise, depth) => {
+    return (data, condition, then, otherwise, nesting) => {
         const id = info.getId(data);
-        const decorated = { ...data, info: { ...data.info, id, parent: undefined, depth }, condition, then, otherwise };
+        const decorated = { ...data, info: { ...data.info, id, parent: undefined, nesting }, condition, then, otherwise };
         info.idMap.set(id, decorated);
         const condInfo = condition.info;
         condInfo.parent = id;
@@ -255,9 +265,9 @@ function createFoldForIfThenElse(info) {
     };
 }
 function createFoldForExprList(info) {
-    return (data, grouping, children, depth) => {
+    return (data, grouping, children, nesting) => {
         const id = info.getId(data);
-        const decorated = { ...data, info: { ...data.info, id, parent: undefined, depth }, grouping, children };
+        const decorated = { ...data, info: { ...data.info, id, parent: undefined, nesting }, grouping, children };
         info.idMap.set(id, decorated);
         let i = 0;
         for (const child of children) {
@@ -270,14 +280,14 @@ function createFoldForExprList(info) {
     };
 }
 function createFoldForFunctionCall(info) {
-    return (data, functionName, args, depth) => {
+    return (data, functionName, args, nesting) => {
         const id = info.getId(data);
         let decorated;
         if (data.named) {
-            decorated = { ...data, info: { ...data.info, id, parent: undefined, depth }, functionName, arguments: args };
+            decorated = { ...data, info: { ...data.info, id, parent: undefined, nesting }, functionName, arguments: args };
         }
         else {
-            decorated = { ...data, info: { ...data.info, id, parent: undefined, depth }, calledFunction: functionName, arguments: args };
+            decorated = { ...data, info: { ...data.info, id, parent: undefined, nesting }, calledFunction: functionName, arguments: args };
         }
         info.idMap.set(id, decorated);
         const funcInfo = functionName.info;
@@ -297,9 +307,9 @@ function createFoldForFunctionCall(info) {
     };
 }
 function createFoldForFunctionDefinition(info) {
-    return (data, params, body, depth) => {
+    return (data, params, body, nesting) => {
         const id = info.getId(data);
-        const decorated = { ...data, info: { ...data.info, id, parent: undefined, depth }, parameters: params, body };
+        const decorated = { ...data, info: { ...data.info, id, parent: undefined, nesting }, parameters: params, body };
         info.idMap.set(id, decorated);
         let idx = 0;
         for (const param of params) {
@@ -316,9 +326,9 @@ function createFoldForFunctionDefinition(info) {
     };
 }
 function createFoldForFunctionParameter(info) {
-    return (data, name, defaultValue, depth) => {
+    return (data, name, defaultValue, nesting) => {
         const id = info.getId(data);
-        const decorated = { ...data, info: { ...data.info, id, parent: undefined, depth }, name, defaultValue };
+        const decorated = { ...data, info: { ...data.info, id, parent: undefined, nesting }, name, defaultValue };
         info.idMap.set(id, decorated);
         const nameInfo = name.info;
         nameInfo.parent = id;
@@ -333,9 +343,9 @@ function createFoldForFunctionParameter(info) {
     };
 }
 function createFoldForFunctionArgument(info) {
-    return (data, name, value, depth) => {
+    return (data, name, value, nesting) => {
         const id = info.getId(data);
-        const decorated = { ...data, info: { ...data.info, id, parent: undefined, depth }, name, value };
+        const decorated = { ...data, info: { ...data.info, id, parent: undefined, nesting }, name, value };
         info.idMap.set(id, decorated);
         let idx = 0;
         if (name) {

package/slicing/static/static-slicer.d.ts

@@ -9,7 +9,7 @@ export declare const slicerLogger: import("tslog").Logger<import("tslog").ILogOb
  * The returned ids can be used to {@link reconstructToCode|reconstruct the slice to R code}.
  *
  * @param graph     - The dataflow graph to conduct the slicing on.
- * @param ast       - The normalized AST of the code (used to get static depth information of the lexemes in case of control flow dependencies that may have no effect on the slicing scope).
+ * @param ast       - The normalized AST of the code (used to get static nesting information of the lexemes in case of control flow dependencies that may have no effect on the slicing scope).
  * @param criteria  - The criteras to slice on.
  * @param threshold - The maximum number of nodes to visit in the graph. If the threshold is reached, the slice will side with inclusion and drop its minimal guarantee. The limit ensures that the algorithm halts.
  */

package/slicing/static/static-slicer.js

@@ -16,7 +16,7 @@ exports.slicerLogger = log_1.log.getSubLogger({ name: 'slicer' });
  * The returned ids can be used to {@link reconstructToCode|reconstruct the slice to R code}.
  *
  * @param graph     - The dataflow graph to conduct the slicing on.
- * @param ast       - The normalized AST of the code (used to get static depth information of the lexemes in case of control flow dependencies that may have no effect on the slicing scope).
+ * @param ast       - The normalized AST of the code (used to get static nesting information of the lexemes in case of control flow dependencies that may have no effect on the slicing scope).
  * @param criteria  - The criteras to slice on.
  * @param threshold - The maximum number of nodes to visit in the graph. If the threshold is reached, the slice will side with inclusion and drop its minimal guarantee. The limit ensures that the algorithm halts.
  */
@@ -25,7 +25,7 @@ function staticSlicing(graph, { idMap }, criteria, threshold = 75) {
     const decodedCriteria = (0, parse_1.convertAllSlicingCriteriaToIds)(criteria, idMap);
     (0, log_1.expensiveTrace)(exports.slicerLogger, () => `calculating slice for ${decodedCriteria.length} seed criteria: ${decodedCriteria.map(s => JSON.stringify(s)).join(', ')}`);
     const queue = new visiting_queue_1.VisitingQueue(threshold);
-    let minDepth = Number.MAX_SAFE_INTEGER;
+    let minNesting = Number.MAX_SAFE_INTEGER;
     const sliceSeedIds = new Set();
     // every node ships the call environment which registers the calling environment
     {
@@ -33,8 +33,8 @@ function staticSlicing(graph, { idMap }, criteria, threshold = 75) {
         const basePrint = (0, fingerprint_1.envFingerprint)(emptyEnv);
         for (const { id: startId } of decodedCriteria) {
             queue.add(startId, emptyEnv, basePrint, false);
-            // retrieve the minimum depth of all nodes to only add control dependencies if they are "part" of the current execution
-            minDepth = Math.min(minDepth, idMap.get(startId)?.info.depth ?? minDepth);
+            // retrieve the minimum nesting of all nodes to only add control dependencies if they are "part" of the current execution
+            minNesting = Math.min(minNesting, idMap.get(startId)?.info.nesting ?? minNesting);
             sliceSeedIds.add(startId);
         }
         /* additionally,
@@ -54,11 +54,11 @@ function staticSlicing(graph, { idMap }, criteria, threshold = 75) {
             continue;
         }
         const [currentVertex, currentEdges] = currentInfo;
-        // we only add control dependencies iff 1) we are in different function call or 2) they have, at least, the same depth as the slicing seed
+        // we only add control dependencies iff 1) we are in different function call or 2) they have, at least, the same nesting as the slicing seed
         if (currentVertex.controlDependencies && currentVertex.controlDependencies.length > 0) {
             const topLevel = graph.isRoot(id) || sliceSeedIds.has(id);
             for (const cd of currentVertex.controlDependencies.filter(({ id }) => !queue.hasId(id))) {
-                if (!topLevel || (idMap.get(cd.id)?.info.depth ?? 0) <= minDepth) {
+                if (!topLevel || (idMap.get(cd.id)?.info.nesting ?? 0) >= minNesting) {
                     queue.add(cd.id, baseEnvironment, baseEnvFingerprint, false);
                 }
             }

package/util/version.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.flowrVersion = void 0;
 const semver_1 = require("semver");
 // this is automatically replaced with the current version by release-it
-const version = '2.0.20';
+const version = '2.0.22';
 function flowrVersion() {
     return new semver_1.SemVer(version);
 }