@eagleoutice/flowr 2.4.1 → 2.4.3

package/README.md

@@ -24,7 +24,7 @@ It offers a wide variety of features, for example:
     
     ```shell
     $ docker run -it --rm eagleoutice/flowr # or npm run flowr 
-    flowR repl using flowR v2.4.0, R v4.5.0 (r-shell engine)
+    flowR repl using flowR v2.4.2, R v4.5.0 (r-shell engine)
     R> :query @linter "read.csv(\"/root/x.txt\")"
     ```
     
@@ -39,7 +39,7 @@ It offers a wide variety of features, for example:
        ╰ **File Path Validity** (file-path-validity):
            ╰ certain:
                ╰ Path `/root/x.txt` at 1.1-23
-           ╰ _Metadata_: <code>{"totalReads":1,"totalUnknown":0,"totalWritesBeforeAlways":0,"totalValid":0,"searchTimeMs":1,"processTimeMs":0}</code>
+           ╰ _Metadata_: <code>{"totalReads":1,"totalUnknown":0,"totalWritesBeforeAlways":0,"totalValid":0,"searchTimeMs":0,"processTimeMs":1}</code>
        ╰ **Seeded Randomness** (seeded-randomness):
            ╰ _Metadata_: <code>{"consumerCalls":0,"callsWithFunctionProducers":0,"callsWithAssignmentProducers":0,"callsWithNonConstantProducers":0,"searchTimeMs":0,"processTimeMs":0}</code>
        ╰ **Absolute Paths** (absolute-file-paths):
@@ -49,11 +49,13 @@ It offers a wide variety of features, for example:
        ╰ **Unused Definitions** (unused-definitions):
            ╰ _Metadata_: <code>{"totalConsidered":0,"searchTimeMs":0,"processTimeMs":0}</code>
        ╰ **Naming Convention** (naming-convention):
-           ╰ _Metadata_: <code>{"numMatches":0,"numBreak":0,"searchTimeMs":1,"processTimeMs":0}</code>
+           ╰ _Metadata_: <code>{"numMatches":0,"numBreak":0,"searchTimeMs":0,"processTimeMs":0}</code>
        ╰ **Dataframe Access Validation** (dataframe-access-validation):
-           ╰ _Metadata_: <code>{"numOperations":0,"numAccesses":0,"totalAccessed":0,"searchTimeMs":0,"processTimeMs":0}</code>
+           ╰ _Metadata_: <code>{"numOperations":0,"numAccesses":0,"totalAccessed":0,"searchTimeMs":0,"processTimeMs":1}</code>
        ╰ **Dead Code** (dead-code):
            ╰ _Metadata_: <code>{"consideredNodes":5,"searchTimeMs":0,"processTimeMs":0}</code>
+       ╰ **Useless Loops** (useless-loop):
+           ╰ _Metadata_: <code>{"numOfUselessLoops":0,"searchTimeMs":0,"processTimeMs":0}</code>
     All queries together required ≈2 ms (1ms accuracy, total 8 ms)
     ```
     
@@ -76,7 +78,7 @@ It offers a wide variety of features, for example:
     
     _Results (prettified and summarized):_
     
-    Query: **linter** (13 ms)\
+    Query: **linter** (14 ms)\
     &nbsp;&nbsp;&nbsp;╰ **Deprecated Functions** (deprecated-functions):\
     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"totalDeprecatedCalls":0,"totalDeprecatedFunctionDefinitions":0,"searchTimeMs":2,"processTimeMs":0}</code>\
     &nbsp;&nbsp;&nbsp;╰ **File Path Validity** (file-path-validity):\
@@ -84,24 +86,26 @@ It offers a wide variety of features, for example:
     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ Path `/root/x.txt` at 1.1-23\
     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"totalReads":1,"totalUnknown":0,"totalWritesBeforeAlways":0,"totalValid":0,"searchTimeMs":4,"processTimeMs":1}</code>\
     &nbsp;&nbsp;&nbsp;╰ **Seeded Randomness** (seeded-randomness):\
-    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"consumerCalls":0,"callsWithFunctionProducers":0,"callsWithAssignmentProducers":0,"callsWithNonConstantProducers":0,"searchTimeMs":0,"processTimeMs":0}</code>\
+    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"consumerCalls":0,"callsWithFunctionProducers":0,"callsWithAssignmentProducers":0,"callsWithNonConstantProducers":0,"searchTimeMs":0,"processTimeMs":1}</code>\
     &nbsp;&nbsp;&nbsp;╰ **Absolute Paths** (absolute-file-paths):\
     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ certain:\
     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ Path `/root/x.txt` at 1.1-23\
-    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"totalConsidered":1,"totalUnknown":0,"searchTimeMs":1,"processTimeMs":0}</code>\
+    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"totalConsidered":1,"totalUnknown":0,"searchTimeMs":2,"processTimeMs":0}</code>\
     &nbsp;&nbsp;&nbsp;╰ **Unused Definitions** (unused-definitions):\
-    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"totalConsidered":0,"searchTimeMs":1,"processTimeMs":0}</code>\
+    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"totalConsidered":0,"searchTimeMs":0,"processTimeMs":0}</code>\
     &nbsp;&nbsp;&nbsp;╰ **Naming Convention** (naming-convention):\
     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"numMatches":0,"numBreak":0,"searchTimeMs":0,"processTimeMs":0}</code>\
     &nbsp;&nbsp;&nbsp;╰ **Dataframe Access Validation** (dataframe-access-validation):\
-    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"numOperations":0,"numAccesses":0,"totalAccessed":0,"searchTimeMs":0,"processTimeMs":2}</code>\
+    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"numOperations":0,"numAccesses":0,"totalAccessed":0,"searchTimeMs":0,"processTimeMs":3}</code>\
     &nbsp;&nbsp;&nbsp;╰ **Dead Code** (dead-code):\
     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"consideredNodes":5,"searchTimeMs":1,"processTimeMs":0}</code>\
-    _All queries together required ≈13 ms (1ms accuracy, total 215 ms)_
+    &nbsp;&nbsp;&nbsp;╰ **Useless Loops** (useless-loop):\
+    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"numOfUselessLoops":0,"searchTimeMs":0,"processTimeMs":0}</code>\
+    _All queries together required ≈14 ms (1ms accuracy, total 209 ms)_
     
     <details> <summary style="color:gray">Show Detailed Results as Json</summary>
     
-    The analysis required _214.5 ms_ (including parsing and normalization and the query) within the generation environment.	
+    The analysis required _208.5 ms_ (including parsing and normalization and the query) within the generation environment.	
     
     In general, the JSON contains the Ids of the nodes in question as they are present in the normalized AST or the dataflow graph of flowR.
     Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Interface) wiki page for more information on how to get those.
@@ -152,7 +156,7 @@ It offers a wide variety of features, for example:
               "callsWithAssignmentProducers": 0,
               "callsWithNonConstantProducers": 0,
               "searchTimeMs": 0,
-              "processTimeMs": 0
+              "processTimeMs": 1
             }
           },
           "absolute-file-paths": {
@@ -171,7 +175,7 @@ It offers a wide variety of features, for example:
             ".meta": {
               "totalConsidered": 1,
               "totalUnknown": 0,
-              "searchTimeMs": 1,
+              "searchTimeMs": 2,
               "processTimeMs": 0
             }
           },
@@ -179,7 +183,7 @@ It offers a wide variety of features, for example:
             "results": [],
             ".meta": {
               "totalConsidered": 0,
-              "searchTimeMs": 1,
+              "searchTimeMs": 0,
               "processTimeMs": 0
             }
           },
@@ -199,7 +203,7 @@ It offers a wide variety of features, for example:
               "numAccesses": 0,
               "totalAccessed": 0,
               "searchTimeMs": 0,
-              "processTimeMs": 2
+              "processTimeMs": 3
             }
           },
           "dead-code": {
@@ -209,14 +213,22 @@ It offers a wide variety of features, for example:
               "searchTimeMs": 1,
               "processTimeMs": 0
             }
+          },
+          "useless-loop": {
+            "results": [],
+            ".meta": {
+              "numOfUselessLoops": 0,
+              "searchTimeMs": 0,
+              "processTimeMs": 0
+            }
           }
         },
         ".meta": {
-          "timing": 13
+          "timing": 14
         }
       },
       ".meta": {
-        "timing": 13
+        "timing": 14
       }
     }
     ```
@@ -283,7 +295,7 @@ It offers a wide variety of features, for example:
     
     ```shell
     $ docker run -it --rm eagleoutice/flowr # or npm run flowr 
-    flowR repl using flowR v2.4.0, R v4.5.0 (r-shell engine)
+    flowR repl using flowR v2.4.2, R v4.5.0 (r-shell engine)
     R> :slicer test/testfiles/example.R --criterion "11@sum"
     ```
     
@@ -330,7 +342,7 @@ It offers a wide variety of features, for example:
         
 
 * 🚀 **fast data- and control-flow graphs**\
-  Within just <i><span title="This measurement is automatically fetched from the latest benchmark!">139.1 ms</span></i> (as of Aug 6, 2025), 
+  Within just <i><span title="This measurement is automatically fetched from the latest benchmark!">132.8 ms</span></i> (as of Aug 19, 2025), 
   _flowR_ can analyze the data- and control-flow of the average real-world R script. See the [benchmarks](https://flowr-analysis.github.io/flowr/wiki/stats/benchmark) for more information,
   and consult the [wiki pages](https://github.com/flowr-analysis/flowr/wiki/Dataflow-Graph) for more details on the dataflow graph.
 
@@ -366,7 +378,7 @@ It offers a wide variety of features, for example:
     
     ```shell
     $ docker run -it --rm eagleoutice/flowr # or npm run flowr 
-    flowR repl using flowR v2.4.0, R v4.5.0 (r-shell engine)
+    flowR repl using flowR v2.4.2, R v4.5.0 (r-shell engine)
     R> :dataflow* test/testfiles/example.R
     ```
     
@@ -667,7 +679,7 @@ It offers a wide variety of features, for example:
     ```
     
     	
-    (The analysis required _13.9 ms_ (including parse and normalize, using the [r-shell](https://github.com/flowr-analysis/flowr/wiki/Engines) engine) within the generation environment.)
+    (The analysis required _14.3 ms_ (including parse and normalize, using the [r-shell](https://github.com/flowr-analysis/flowr/wiki/Engines) engine) within the generation environment.)
     
     
     

package/control-flow/simple-visitor.js

@@ -35,9 +35,9 @@ visitor) {
                 queue = queue.concat(get.elems.toReversed().map(e => e.id));
             }
         }
-        const incoming = graph.outgoingEdges(current) ?? [];
-        for (const [from] of incoming) {
-            queue.push(from);
+        const incoming = graph.outgoingEdges(current);
+        if (incoming) {
+            queue.push(...incoming.keys());
         }
     }
 }

package/control-flow/useless-loop.d.ts

@@ -0,0 +1,19 @@
+import type { FlowrConfigOptions } from '../config';
+import type { DataflowGraph } from '../dataflow/graph/graph';
+import type { NormalizedAst } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { ControlFlowInformation } from './control-flow-graph';
+export declare const loopyFunctions: Set<"builtin:default" | "builtin:eval" | "builtin:apply" | "builtin:expression-list" | "builtin:source" | "builtin:access" | "builtin:if-then-else" | "builtin:get" | "builtin:rm" | "builtin:library" | "builtin:assignment" | "builtin:special-bin-op" | "builtin:pipe" | "builtin:function-definition" | "builtin:quote" | "builtin:for-loop" | "builtin:repeat-loop" | "builtin:while-loop" | "builtin:replacement" | "builtin:list" | "builtin:vector">;
+/**
+ * Checks whether a loop only loops once
+ *
+ *
+ *
+ * @param loop        - nodeid of the loop to analyse
+ * @param dataflow    - dataflow graph
+ * @param controlflow - control flow graph
+ * @param ast         - normalized ast
+ * @param config      - current flowr config
+ * @returns true if the given loop only iterates once
+ */
+export declare function onlyLoopsOnce(loop: NodeId, dataflow: DataflowGraph, controlflow: ControlFlowInformation, ast: NormalizedAst, config: FlowrConfigOptions): boolean | undefined;

package/control-flow/useless-loop.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loopyFunctions = void 0;
+exports.onlyLoopsOnce = onlyLoopsOnce;
+const alias_tracking_1 = require("../dataflow/eval/resolve/alias-tracking");
+const general_1 = require("../dataflow/eval/values/general");
+const r_value_1 = require("../dataflow/eval/values/r-value");
+const vertex_1 = require("../dataflow/graph/vertex");
+const info_1 = require("../dataflow/info");
+const r_function_call_1 = require("../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const assert_1 = require("../util/assert");
+const semantic_cfg_guided_visitor_1 = require("./semantic-cfg-guided-visitor");
+exports.loopyFunctions = new Set(['builtin:for-loop', 'builtin:while-loop', 'builtin:repeat-loop']);
+/**
+ * Checks whether a loop only loops once
+ *
+ *
+ *
+ * @param loop        - nodeid of the loop to analyse
+ * @param dataflow    - dataflow graph
+ * @param controlflow - control flow graph
+ * @param ast         - normalized ast
+ * @param config      - current flowr config
+ * @returns true if the given loop only iterates once
+ */
+function onlyLoopsOnce(loop, dataflow, controlflow, ast, config) {
+    const vertex = dataflow.getVertex(loop);
+    if (!vertex) {
+        return undefined;
+    }
+    (0, assert_1.guard)(vertex.tag === vertex_1.VertexType.FunctionCall, 'invalid vertex type for onlyLoopsOnce');
+    (0, assert_1.guard)(vertex.origin !== 'unnamed' && exports.loopyFunctions.has(vertex.origin[0]), 'onlyLoopsOnce can only be called with loops');
+    // 1. In case of for loop, check if vector has only one element
+    if (vertex.origin[0] === 'builtin:for-loop') {
+        if (vertex.args.length < 2) {
+            return undefined;
+        }
+        const vectorOfLoop = vertex.args[1];
+        if (vectorOfLoop === r_function_call_1.EmptyArgument) {
+            return undefined;
+        }
+        const values = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(vectorOfLoop.nodeId, { graph: dataflow, idMap: dataflow.idMap, resolve: config.solver.variables }));
+        if (values === undefined || values.elements.length !== 1 || values.elements[0].type !== 'vector' || !(0, r_value_1.isValue)(values.elements[0].elements)) {
+            return undefined;
+        }
+        if (values.elements[0].elements.length === 1) {
+            return true;
+        }
+    }
+    // 2. Use CFG Visitor to determine if loop always exits after the first iteration
+    const visitor = new CfgSingleIterationLoopDetector(loop, {
+        controlFlow: controlflow,
+        normalizedAst: ast,
+        dfg: dataflow,
+        flowrConfig: config,
+        defaultVisitingOrder: 'forward'
+    });
+    return visitor.loopsOnlyOnce();
+}
+class CfgSingleIterationLoopDetector extends semantic_cfg_guided_visitor_1.SemanticCfgGuidedVisitor {
+    onlyLoopyOnce = false;
+    loopToCheck;
+    constructor(loop, config) {
+        super(config);
+        this.loopToCheck = loop;
+    }
+    getBoolArgValue(data) {
+        if (data.call.args.length !== 1 || data.call.args[0] === r_function_call_1.EmptyArgument) {
+            return undefined;
+        }
+        const values = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(data.call.args[0].nodeId, { graph: this.config.dfg, full: true, idMap: this.config.normalizedAst.idMap, resolve: this.config.flowrConfig.solver.variables }));
+        if (values === undefined || values.elements.length !== 1 || values.elements[0].type != 'logical' || !(0, r_value_1.isValue)(values.elements[0].value)) {
+            return undefined;
+        }
+        return Boolean(values.elements[0].value);
+    }
+    startVisitor(_) {
+        const g = this.config.controlFlow.graph;
+        const n = (i) => g.ingoingEdges(i);
+        const exits = new Set(g.getVertex(this.loopToCheck)?.end ?? []);
+        (0, assert_1.guard)(exits.size !== 0, "Can't find end of loop");
+        const stack = [this.loopToCheck];
+        while (stack.length > 0) {
+            const current = stack.shift();
+            if (!this.visitNode(current)) {
+                continue;
+            }
+            if (!exits.has(current)) {
+                const next = n(current) ?? [];
+                for (const [to] of next) {
+                    stack.unshift(to);
+                }
+            }
+        }
+    }
+    onDefaultFunctionCall(data) {
+        let stopsLoop = false;
+        const alwaysHappens = () => {
+            if (!data.call.cds ||
+                (data.call.cds.length === 1 && data.call.cds[0].id === this.loopToCheck)) {
+                return true;
+            }
+            const cds = data.call.cds.filter(d => d.id !== this.loopToCheck);
+            return (0, info_1.happensInEveryBranch)(cds);
+        };
+        switch (data.call.origin[0]) {
+            case 'builtin:return':
+            case 'builtin:stop':
+            case 'builtin:break':
+                stopsLoop = alwaysHappens();
+                break;
+            case 'builtin:stopifnot': {
+                const arg = this.getBoolArgValue(data);
+                if (arg !== undefined) {
+                    stopsLoop = !arg && alwaysHappens();
+                }
+                break;
+            }
+        }
+        this.onlyLoopyOnce = this.onlyLoopyOnce || stopsLoop;
+    }
+    loopsOnlyOnce() {
+        this.startVisitor([]);
+        return this.onlyLoopyOnce;
+    }
+}
+//# sourceMappingURL=useless-loop.js.map

package/dataflow/environments/built-in.d.ts

@@ -65,7 +65,6 @@ export interface DefaultBuiltInProcessorConfiguration extends ForceArguments {
 }
 export type BuiltInEvalHandler = (resolve: VariableResolve, a: RNodeWithParent, env?: REnvironmentInformation, graph?: DataflowGraph, map?: AstIdMap) => Value;
 declare function defaultBuiltInProcessor<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, { returnsNthArgument, useAsProcessor, forceArgs, readAllArguments, cfg, hasUnknownSideEffects, treatAsFnCall }: DefaultBuiltInProcessorConfiguration): DataflowInformation;
-export declare function registerBuiltInFunctions<Config extends object, Proc extends BuiltInIdentifierProcessorWithConfig<Config>>(both: boolean, names: readonly Identifier[], processor: Proc, config: Config, builtIns: BuiltIns): void;
 export declare const BuiltInProcessorMapper: {
     readonly 'builtin:default': typeof defaultBuiltInProcessor;
     readonly 'builtin:eval': typeof processEvalCall;

package/dataflow/environments/built-in.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BuiltIns = exports.BuiltInEvalHandlerMapper = exports.BuiltInProcessorMapper = void 0;
 exports.builtInId = builtInId;
 exports.isBuiltIn = isBuiltIn;
-exports.registerBuiltInFunctions = registerBuiltInFunctions;
 const known_call_handling_1 = require("../internal/process/functions/call/known-call-handling");
 const built_in_access_1 = require("../internal/process/functions/call/built-in/built-in-access");
 const built_in_if_then_else_1 = require("../internal/process/functions/call/built-in/built-in-if-then-else");
@@ -99,22 +98,6 @@ function defaultBuiltInProcessor(name, args, rootId, data, { returnsNthArgument,
     }
     return res;
 }
-function registerBuiltInFunctions(both, names, processor, config, builtIns) {
-    for (const name of names) {
-        (0, assert_1.guard)(processor !== undefined, `Processor for ${name} is undefined, maybe you have an import loop? You may run 'npm run detect-circular-deps' - although by far not all are bad`);
-        const id = builtInId(name);
-        const d = [{
-                type: identifier_1.ReferenceType.BuiltInFunction,
-                definedAt: id,
-                controlDependencies: undefined,
-                processor: (name, args, rootId, data) => processor(name, args, rootId, data, config),
-                config,
-                name,
-                nodeId: id
-            }];
-        builtIns.set(name, d, both);
-    }
-}
 exports.BuiltInProcessorMapper = {
     'builtin:default': defaultBuiltInProcessor,
     'builtin:eval': built_in_eval_1.processEvalCall,

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

@@ -218,7 +218,7 @@ exports.DefaultBuiltinConfig = [
     { type: 'function', names: ['return'], processor: 'builtin:default', config: { returnsNthArgument: 0, cfg: 1 /* ExitPointType.Return */, useAsProcessor: 'builtin:return' }, assumePrimitive: false },
     { type: 'function', names: ['stop'], processor: 'builtin:default', config: { useAsProcessor: 'builtin:stop' }, assumePrimitive: false },
     { type: 'function', names: ['stopifnot'], processor: 'builtin:default', config: { useAsProcessor: 'builtin:stopifnot' }, assumePrimitive: false },
-    { type: 'function', names: ['break'], processor: 'builtin:default', config: { cfg: 2 /* ExitPointType.Break */ }, assumePrimitive: false },
+    { type: 'function', names: ['break'], processor: 'builtin:default', config: { useAsProcessor: 'builtin:break', cfg: 2 /* ExitPointType.Break */ }, assumePrimitive: false },
     { type: 'function', names: ['next'], processor: 'builtin:default', config: { cfg: 3 /* ExitPointType.Next */ }, assumePrimitive: false },
     { type: 'function', names: ['{'], processor: 'builtin:expression-list', config: {}, assumePrimitive: true },
     { type: 'function', names: ['source'], processor: 'builtin:source', config: { includeFunctionCall: true, forceFollow: false }, assumePrimitive: false },

package/dataflow/environments/overwrite.js

@@ -23,7 +23,7 @@ function overwriteIEnvironmentWith(base, next, includeParent = true, applyCds) {
         if (values.length > 1_000_000) {
             log_1.log.warn(`Overwriting environment with ${values.length} definitions for ${key}`);
         }
-        const hasMaybe = applyCds?.length === 0 || applyCds !== undefined ? true : anyIsMaybeOrEmpty(values);
+        const hasMaybe = applyCds !== undefined ? true : anyIsMaybeOrEmpty(values);
         if (hasMaybe) {
             const old = map.get(key);
             // we need to make a copy to avoid side effects for old reference in other environments
@@ -34,7 +34,7 @@ function overwriteIEnvironmentWith(base, next, includeParent = true, applyCds) {
                     if (applyCds !== undefined) {
                         updatedOld.push({
                             ...v,
-                            controlDependencies: [...applyCds, ...v.controlDependencies ?? []]
+                            controlDependencies: applyCds.concat(v.controlDependencies ?? [])
                         });
                     }
                     else {

package/dataflow/graph/graph.d.ts

@@ -160,7 +160,7 @@ export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = Data
      *
      * @see #edges
      */
-    vertices(includeDefinedFunctions: boolean): MapIterator<[NodeId, Vertex]>;
+    vertices(includeDefinedFunctions: boolean): IterableIterator<[NodeId, Vertex]>;
     /**
      * @returns the ids of all edges in the graph together with their edge information
      *

package/dataflow/internal/linker.js

@@ -25,7 +25,7 @@ const built_in_1 = require("../environments/built-in");
 const prefix_1 = require("../../util/prefix");
 function findNonLocalReads(graph, ignore) {
     const ignores = new Set(ignore.map(i => i.nodeId));
-    const ids = new Set(graph.vertices(true)
+    const ids = new Set([...graph.vertices(true)]
         .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 */
@@ -169,7 +169,7 @@ function linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefin
         return;
     }
     const readBits = edge_1.EdgeType.Reads | edge_1.EdgeType.Calls;
-    const functionDefinitionReadIds = edges.entries().filter(([_, e]) => (0, edge_1.edgeDoesNotIncludeType)(e.types, edge_1.EdgeType.Argument)
+    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)[0];
     for (const def of functionDefs.values()) {
@@ -189,11 +189,11 @@ function linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefin
  * @param thisGraph - The graph to search for function calls in
  */
 function linkFunctionCalls(graph, idMap, thisGraph) {
-    const functionCalls = thisGraph.vertices(true)
-        .filter(([_, info]) => info.tag === vertex_1.VertexType.FunctionCall);
     const calledFunctionDefinitions = [];
-    for (const [id, info] of functionCalls) {
-        linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefinitions);
+    for (const [id, info] of thisGraph.vertices(true)) {
+        if (info.tag === vertex_1.VertexType.FunctionCall) {
+            linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefinitions);
+        }
     }
     return calledFunctionDefinitions;
 }

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

@@ -150,7 +150,7 @@ function processExpressionList(name, args, rootId, data) {
             controlDependencies: data.controlDependencies
         });
     }
-    const ingoing = [...remainingRead.values().flatMap(v => v)];
+    const ingoing = [...remainingRead.values()].flat();
     const rootNode = data.completeAst.idMap.get(rootId);
     const withGroup = rootNode?.grouping;
     if (withGroup) {

package/documentation/print-linter-wiki.js

@@ -114,6 +114,7 @@ df <- data.frame(id = 1:5, name = 6:10)
 df[6, "value"]
 `, tagTypes);
     rule(shell, 'dead-code', 'DeadCodeConfig', 'DEAD_CODE', 'lint-dead-code', 'if(TRUE) 1 else 2', tagTypes);
+    rule(shell, 'useless-loop', 'UselessLoopConfig', 'USELESS_LOOP', 'lint-useless-loop', 'for(i in c(1)) { print(i) }', tagTypes);
     function rule(shell, name, configType, ruleType, testfile, example, types) {
         const rule = linter_rules_1.LintingRules[name];
         const tags = rule.info.tags.toSorted((a, b) => {

package/linter/linter-rules.d.ts

@@ -225,6 +225,36 @@ export declare const LintingRules: {
             readonly defaultConfig: {};
         };
     };
+    readonly 'useless-loop': {
+        readonly createSearch: () => import("../search/flowr-search-builder").FlowrSearchBuilder<"all", ["filter"], import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, [] | import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>>;
+        readonly processSearchResult: (elements: import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, config: import("./rules/useless-loop").UselessLoopConfig, data: {
+            normalize: import("../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+            dataflow: import("../dataflow/info").DataflowInformation;
+            config: import("../config").FlowrConfigOptions;
+        }) => {
+            results: {
+                certainty: import("./linter-format").LintingResultCertainty.Certain;
+                name: string;
+                range: import("../util/range").SourceRange;
+            }[];
+            '.meta': {
+                numOfUselessLoops: number;
+            };
+        };
+        readonly prettyPrint: {
+            readonly query: (result: import("./rules/useless-loop").UselessLoopResult) => string;
+            readonly full: (result: import("./rules/useless-loop").UselessLoopResult) => string;
+        };
+        readonly info: {
+            readonly name: "Useless Loops";
+            readonly description: "Detect loops which only iterate once";
+            readonly certainty: import("./linter-format").LintingRuleCertainty.BestEffort;
+            readonly tags: readonly [import("./linter-tags").LintingRuleTag.Smell, import("./linter-tags").LintingRuleTag.Readability];
+            readonly defaultConfig: {
+                readonly loopyFunctions: Set<"builtin:default" | "builtin:eval" | "builtin:apply" | "builtin:expression-list" | "builtin:source" | "builtin:access" | "builtin:if-then-else" | "builtin:get" | "builtin:rm" | "builtin:library" | "builtin:assignment" | "builtin:special-bin-op" | "builtin:pipe" | "builtin:function-definition" | "builtin:quote" | "builtin:for-loop" | "builtin:repeat-loop" | "builtin:while-loop" | "builtin:replacement" | "builtin:list" | "builtin:vector">;
+            };
+        };
+    };
 };
 export type LintingRuleNames = keyof typeof LintingRules;
 export type LintingRuleMetadata<Name extends LintingRuleNames> = typeof LintingRules[Name] extends LintingRule<infer _Result, infer Metadata, infer _Config, infer _Info, infer _Elements> ? Metadata : never;

package/linter/linter-rules.js

@@ -9,6 +9,7 @@ const dead_code_1 = require("./rules/dead-code");
 const seeded_randomness_1 = require("./rules/seeded-randomness");
 const naming_convention_1 = require("./rules/naming-convention");
 const dataframe_access_validation_1 = require("./rules/dataframe-access-validation");
+const useless_loop_1 = require("./rules/useless-loop");
 /**
  * The registry of currently supported linting rules.
  * A linting rule can be executed on a dataflow pipeline result using {@link executeLintingRule}.
@@ -22,5 +23,6 @@ exports.LintingRules = {
     'naming-convention': naming_convention_1.NAMING_CONVENTION,
     'dataframe-access-validation': dataframe_access_validation_1.DATA_FRAME_ACCESS_VALIDATION,
     'dead-code': dead_code_1.DEAD_CODE,
+    'useless-loop': useless_loop_1.USELESS_LOOP
 };
 //# sourceMappingURL=linter-rules.js.map

package/linter/rules/useless-loop.d.ts

@@ -0,0 +1,47 @@
+import type { BuiltInMappingName } from '../../dataflow/environments/built-in';
+import type { MergeableRecord } from '../../util/objects';
+import type { SourceRange } from '../../util/range';
+import type { LintingResult } from '../linter-format';
+import { LintingResultCertainty, LintingRuleCertainty } from '../linter-format';
+import { LintingRuleTag } from '../linter-tags';
+export interface UselessLoopResult extends LintingResult {
+    name: string;
+    range: SourceRange;
+}
+export interface UselessLoopConfig extends MergeableRecord {
+    /** Function origins that are considered loops */
+    loopyFunctions: Set<BuiltInMappingName>;
+}
+export interface UselessLoopMetadata extends MergeableRecord {
+    numOfUselessLoops: number;
+}
+export declare const USELESS_LOOP: {
+    readonly createSearch: () => import("../../search/flowr-search-builder").FlowrSearchBuilder<"all", ["filter"], import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../search/flowr-search").FlowrSearchElements<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, [] | import("../../search/flowr-search").FlowrSearchElement<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>>;
+    readonly processSearchResult: (elements: import("../../search/flowr-search").FlowrSearchElements<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../search/flowr-search").FlowrSearchElement<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, config: UselessLoopConfig, data: {
+        normalize: import("../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+        dataflow: import("../../dataflow/info").DataflowInformation;
+        config: import("../../config").FlowrConfigOptions;
+    }) => {
+        results: {
+            certainty: LintingResultCertainty.Certain;
+            name: string;
+            range: SourceRange;
+        }[];
+        '.meta': {
+            numOfUselessLoops: number;
+        };
+    };
+    readonly prettyPrint: {
+        readonly query: (result: UselessLoopResult) => string;
+        readonly full: (result: UselessLoopResult) => string;
+    };
+    readonly info: {
+        readonly name: "Useless Loops";
+        readonly description: "Detect loops which only iterate once";
+        readonly certainty: LintingRuleCertainty.BestEffort;
+        readonly tags: readonly [LintingRuleTag.Smell, LintingRuleTag.Readability];
+        readonly defaultConfig: {
+            readonly loopyFunctions: Set<"builtin:default" | "builtin:eval" | "builtin:apply" | "builtin:expression-list" | "builtin:source" | "builtin:access" | "builtin:if-then-else" | "builtin:get" | "builtin:rm" | "builtin:library" | "builtin:assignment" | "builtin:special-bin-op" | "builtin:pipe" | "builtin:function-definition" | "builtin:quote" | "builtin:for-loop" | "builtin:repeat-loop" | "builtin:while-loop" | "builtin:replacement" | "builtin:list" | "builtin:vector">;
+        };
+    };
+};

package/linter/rules/useless-loop.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.USELESS_LOOP = void 0;
+const extract_cfg_1 = require("../../control-flow/extract-cfg");
+const useless_loop_1 = require("../../control-flow/useless-loop");
+const vertex_1 = require("../../dataflow/graph/vertex");
+const flowr_search_builder_1 = require("../../search/flowr-search-builder");
+const dfg_1 = require("../../util/mermaid/dfg");
+const linter_format_1 = require("../linter-format");
+const linter_tags_1 = require("../linter-tags");
+exports.USELESS_LOOP = {
+    createSearch: () => flowr_search_builder_1.Q.all().filter(vertex_1.VertexType.FunctionCall),
+    processSearchResult: (elements, config, data) => {
+        const cfg = (0, extract_cfg_1.extractCfg)(data.normalize, data.config, data.dataflow.graph);
+        const results = elements.getElements().filter(e => {
+            const vertex = data.dataflow.graph.getVertex(e.node.info.id);
+            return vertex
+                && (0, vertex_1.isFunctionCallVertex)(vertex)
+                && vertex.origin !== 'unnamed'
+                && config.loopyFunctions.has(vertex.origin[0]);
+        }).filter(loop => (0, useless_loop_1.onlyLoopsOnce)(loop.node.info.id, data.dataflow.graph, cfg, data.normalize, data.config)).map(res => ({
+            certainty: linter_format_1.LintingResultCertainty.Certain,
+            name: res.node.lexeme,
+            range: res.node.info.fullRange
+        }));
+        return {
+            results: results,
+            '.meta': {
+                numOfUselessLoops: results.length
+            }
+        };
+    },
+    prettyPrint: {
+        [linter_format_1.LintingPrettyPrintContext.Query]: result => `${result.name}-loop at ${(0, dfg_1.formatRange)(result.range)} only loops once`,
+        [linter_format_1.LintingPrettyPrintContext.Full]: result => `${result.name}-loop at ${(0, dfg_1.formatRange)(result.range)} only loops once`
+    },
+    info: {
+        name: 'Useless Loops',
+        description: 'Detect loops which only iterate once',
+        certainty: linter_format_1.LintingRuleCertainty.BestEffort,
+        tags: [linter_tags_1.LintingRuleTag.Smell, linter_tags_1.LintingRuleTag.Readability],
+        defaultConfig: {
+            loopyFunctions: useless_loop_1.loopyFunctions
+        }
+    }
+};
+//# sourceMappingURL=useless-loop.js.map

package/package.json

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

package/queries/catalog/call-context-query/identify-link-to-last-call-relation.js

@@ -108,7 +108,7 @@ function getValueOfArgument(graph, call, argument, additionalAllowedTypes) {
     }
 }
 function identifyLinkToLastCallRelation(from, cfg, graph, { callName, ignoreIf, cascadeIf }) {
-    if (ignoreIf && ignoreIf(from, graph)) {
+    if (ignoreIf?.(from, graph)) {
         return [];
     }
     const found = [];

package/util/version.js

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