@eagleoutice/flowr 2.8.0 → 2.8.1

package/dataflow/environments/default-builtin-config.d.ts

@@ -383,6 +383,7 @@ export declare const DefaultBuiltinConfig: [{
     readonly processor: "builtin:assignment";
     readonly config: {
         readonly targetVariable: true;
+        readonly mayHaveMoreArgs: true;
     };
     readonly assumePrimitive: true;
 }, {

package/dataflow/environments/default-builtin-config.js

@@ -247,7 +247,7 @@ exports.DefaultBuiltinConfig = [
     { type: 'function', names: ['library', 'require'], processor: 'builtin:library', config: {}, assumePrimitive: false },
     { type: 'function', names: ['<-', '='], processor: 'builtin:assignment', config: { canBeReplacement: true }, assumePrimitive: true },
     { type: 'function', names: [':='], processor: 'builtin:assignment', config: {}, assumePrimitive: true },
-    { type: 'function', names: ['assign', 'setGeneric', 'setValidity'], processor: 'builtin:assignment', config: { targetVariable: true }, assumePrimitive: true },
+    { type: 'function', names: ['assign', 'setGeneric', 'setValidity'], processor: 'builtin:assignment', config: { targetVariable: true, mayHaveMoreArgs: true }, assumePrimitive: true },
     { type: 'function', names: ['setMethod'], processor: 'builtin:assignment-like', config: { targetVariable: true, canBeReplacement: false, target: { idx: 0, name: 'f' }, source: { idx: 2, name: 'definition' } }, assumePrimitive: true },
     { type: 'function', names: ['delayedAssign'], processor: 'builtin:assignment', config: { quoteSource: true, targetVariable: true }, assumePrimitive: true },
     { type: 'function', names: ['<<-'], processor: 'builtin:assignment', config: { superAssignment: true, canBeReplacement: true }, assumePrimitive: true },

package/dataflow/graph/call-graph.js

@@ -41,10 +41,10 @@ function computeCallGraph(graph) {
         knownReachability: new defaultmap_1.DefaultMap(() => new Set())
     };
     for (const [, vert] of graph.vertices(false)) {
-        if (vert?.tag === vertex_1.VertexType.FunctionCall) {
+        if (vert.tag === vertex_1.VertexType.FunctionCall) {
             processCall(vert, undefined, graph, result, state);
         }
-        else if (vert?.tag === vertex_1.VertexType.FunctionDefinition) {
+        else if (vert.tag === vertex_1.VertexType.FunctionDefinition) {
             processFunctionDefinition(vert, undefined, graph, result, state);
         }
     }
@@ -74,6 +74,8 @@ function processCds(vtx, graph, result, state) {
         }
     }
 }
+const UntargetedCallFollow = edge_1.EdgeType.Reads | edge_1.EdgeType.DefinedByOnCall | edge_1.EdgeType.DefinedBy | edge_1.EdgeType.Returns;
+const UntargetedCallAvoid = edge_1.EdgeType.NonStandardEvaluation | edge_1.EdgeType.Argument;
 /**
  * This tracks the known symbol origins for a function call for which we know that flowr found no targets!
  */
@@ -94,7 +96,7 @@ function fallbackUntargetedCall(vtx, graph) {
         }
         let addedNew = false;
         for (const [tar, { types }] of graph.outgoingEdges(currentId) ?? []) {
-            if ((0, edge_1.edgeIncludesType)(types, edge_1.EdgeType.Reads | edge_1.EdgeType.DefinedByOnCall | edge_1.EdgeType.DefinedBy | edge_1.EdgeType.Returns) && (0, edge_1.edgeDoesNotIncludeType)(types, edge_1.EdgeType.NonStandardEvaluation | edge_1.EdgeType.Argument)) {
+            if ((0, edge_1.edgeIncludesType)(types, UntargetedCallFollow) && (0, edge_1.edgeDoesNotIncludeType)(types, UntargetedCallAvoid)) {
                 addedNew = true;
                 toVisit.push(tar);
             }
@@ -107,21 +109,22 @@ function fallbackUntargetedCall(vtx, graph) {
     return collected;
 }
 function processCall(vtx, from, graph, result, state) {
-    if (from && !reaches(from, vtx.id, result, state.knownReachability)) {
-        result.addEdge(from, vtx.id, edge_1.EdgeType.Calls);
+    const vid = vtx.id;
+    if (from && !reaches(from, vid, result, state.knownReachability)) {
+        result.addEdge(from, vid, edge_1.EdgeType.Calls);
     }
-    if (state.visited.has(vtx.id)) {
+    if (state.visited.has(vid)) {
         return;
     }
+    state.visited.add(vid);
     result.addVertex(vtx, undefined, true);
     processCds(vtx, graph, result, state);
-    state.visited.add(vtx.id);
     // for each call, resolve the targets
-    const tars = (0, linker_1.getAllFunctionCallTargets)(vtx.id, graph, vtx.environment);
+    const tars = (0, linker_1.getAllFunctionCallTargets)(vid, graph, vtx.environment);
     let addedTarget = false;
     for (const tar of tars) {
         if ((0, built_in_1.isBuiltIn)(tar)) {
-            result.addEdge(vtx.id, tar, edge_1.EdgeType.Calls);
+            result.addEdge(vid, tar, edge_1.EdgeType.Calls);
             addedTarget = true;
             continue;
         }
@@ -130,13 +133,13 @@ function processCall(vtx, from, graph, result, state) {
             continue;
         }
         addedTarget = true;
-        processFunctionDefinition(targetVtx, vtx.id, graph, result, state);
+        processFunctionDefinition(targetVtx, vid, graph, result, state);
     }
     if (vtx.origin !== 'unnamed') {
         for (const origs of vtx.origin) {
             if (origs.startsWith('builtin:')) {
                 addedTarget = true;
-                result.addEdge(vtx.id, (0, built_in_1.builtInId)(origs.substring('builtin:'.length)), edge_1.EdgeType.Calls);
+                result.addEdge(vid, (0, built_in_1.builtInId)(origs.substring('builtin:'.length)), edge_1.EdgeType.Calls);
             }
         }
     }
@@ -147,7 +150,7 @@ function processCall(vtx, from, graph, result, state) {
             if (!oriVtx) {
                 continue;
             }
-            result.addEdge(vtx.id, ori, edge_1.EdgeType.Calls);
+            result.addEdge(vid, ori, edge_1.EdgeType.Calls);
             const name = graph.idMap?.get(ori);
             if (name?.lexeme && oriVtx.tag === vertex_1.VertexType.Use) {
                 result.addVertex({
@@ -198,12 +201,12 @@ function processFunctionDefinition(vtx, from, graph, result, state) {
     result.addVertex(vtx, undefined, true);
     processCds(vtx, graph, result, state);
     const exits = new Set(vtx.exitPoints);
+    state.potentials.push([vtx.id, vtx.subflow.graph.difference(exits)]);
     for (const { nodeId } of exits) {
         const v = graph.getVertex(nodeId, true);
         if (v) {
             processUnknown(v, vtx.id, graph, result, state);
         }
     }
-    state.potentials.push([vtx.id, vtx.subflow.graph.difference(exits)]);
 }
 //# sourceMappingURL=call-graph.js.map

package/dataflow/internal/linker.js

@@ -34,33 +34,21 @@ function findNonLocalReads(graph, ignore) {
     const ids = new Set(graph.vertexIdsOfType(vertex_1.VertexType.Use).concat(graph.vertexIdsOfType(vertex_1.VertexType.FunctionCall)));
     /* find all variable use ids which do not link to a given id */
     const nonLocalReads = [];
-    for (const id of ids) {
-        if (ignores.has(id)) {
+    for (const nodeId of ids) {
+        if (ignores.has(nodeId)) {
             continue;
         }
-        const outgoing = graph.outgoingEdges(id);
-        const name = (0, node_id_1.recoverName)(id, graph.idMap);
-        const origin = graph.getVertex(id, true);
+        const outgoing = graph.outgoingEdges(nodeId);
+        const name = (0, node_id_1.recoverName)(nodeId, graph.idMap);
+        const origin = graph.getVertex(nodeId, true);
+        const type = origin?.tag === vertex_1.VertexType.FunctionCall ? identifier_1.ReferenceType.Function : identifier_1.ReferenceType.Variable;
         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
-            });
+            nonLocalReads.push({ name, nodeId, type });
             continue;
         }
         for (const [target, { types }] of outgoing) {
             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,
-                    type: origin?.tag === vertex_1.VertexType.FunctionCall ? identifier_1.ReferenceType.Function : identifier_1.ReferenceType.Variable
-                });
+                nonLocalReads.push({ name, nodeId, type });
                 break;
             }
         }

package/package.json

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

package/queries/catalog/inspect-higher-order-query/inspect-higher-order-query-executor.js

@@ -2,16 +2,41 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeHigherOrderQuery = executeHigherOrderQuery;
 const higher_order_function_1 = require("../../../dataflow/fn/higher-order-function");
-const inspect_exception_query_executor_1 = require("../inspect-exceptions-query/inspect-exception-query-executor");
+const parse_1 = require("../../../slicing/criterion/parse");
+const vertex_1 = require("../../../dataflow/graph/vertex");
 /**
  * Execute higher-order function inspection queries on the given analyzer.
  */
 async function executeHigherOrderQuery({ analyzer }, queries) {
     const start = Date.now();
-    const { cg, fns } = await (0, inspect_exception_query_executor_1.getFunctionsToConsiderInCallGraph)(queries, analyzer);
+    let filters = undefined;
+    // filter will remain undefined if at least one of the queries wants all functions
+    for (const q of queries) {
+        if (q.filter === undefined) {
+            filters = undefined;
+            break;
+        }
+        else {
+            filters ??= [];
+            filters = filters.concat(q.filter);
+        }
+    }
+    const ast = await analyzer.normalize();
+    const filterFor = new Set();
+    if (filters) {
+        for (const f of filters) {
+            const i = (0, parse_1.tryResolveSliceCriterionToId)(f, ast.idMap);
+            if (i !== undefined) {
+                filterFor.add(i);
+            }
+        }
+    }
+    const graph = (await analyzer.dataflow()).graph;
+    const fns = graph.verticesOfType(vertex_1.VertexType.FunctionDefinition)
+        .filter(([, v]) => filterFor.size === 0 || filterFor.has(v.id));
     const result = {};
     for (const [id,] of fns) {
-        result[id] = (0, higher_order_function_1.isFunctionHigherOrder)(id, cg, analyzer.inspectContext());
+        result[id] = (0, higher_order_function_1.isFunctionHigherOrder)(id, graph, analyzer.inspectContext());
     }
     return {
         '.meta': {

package/util/version.js

@@ -6,7 +6,7 @@ exports.printVersionInformation = printVersionInformation;
 const semver_1 = require("semver");
 const assert_1 = require("./assert");
 // this is automatically replaced with the current version by release-it
-const version = '2.8.0';
+const version = '2.8.1';
 /**
  * Retrieves the current flowR version as a new {@link SemVer} object.
  */