@eagleoutice/flowr 2.9.8 → 2.9.10

package/abstract-interpretation/domains/abstract-domain.js

@@ -48,19 +48,19 @@ class AbstractDomain {
     }
     /**
      * Joins an array of abstract values by joining the first abstract value with the other values in the array.
-     * The provided array of abstract values cannot be empty!
+     * The provided array of abstract values must not be empty or a default value must be provided!
      */
-    static joinAll(values) {
-        (0, assert_1.guard)(values.length > 0, 'Abstract values to join cannot be empty');
-        return values[0].joinAll(values.slice(1));
+    static joinAll(values, defaultValue) {
+        (0, assert_1.guard)(values.length > 0 || defaultValue !== undefined, 'Abstract values to join cannot be empty');
+        return values[0]?.joinAll(values.slice(1)) ?? defaultValue;
     }
     /**
      * Meets an array of abstract values by meeting the first abstract value with the other values in the array.
-     * The provided array of abstract values cannot be empty!
+     * The provided array of abstract values must not be empty or a default value must be provided!
      */
-    static meetAll(values) {
-        (0, assert_1.guard)(values.length > 0, 'Abstract values to meet cannot be empty');
-        return values[0].meetAll(values.slice(1));
+    static meetAll(values, defaultValue) {
+        (0, assert_1.guard)(values.length > 0 || defaultValue !== undefined, 'Abstract values to meet cannot be empty');
+        return values[0]?.meetAll(values.slice(1)) ?? defaultValue;
     }
 }
 exports.AbstractDomain = AbstractDomain;

package/abstract-interpretation/domains/mapped-abstract-domain.d.ts

@@ -1,19 +1,19 @@
 import { AbstractDomain, type AnyAbstractDomain, type ConcreteDomain } from './abstract-domain';
 import { Top } from './lattice';
 /** The type of the concrete mapping of the concrete domain of a mapped abstract domain mapping keys to a concrete value in the concrete domain */
-type ConcreteMap<Key, Domain extends AnyAbstractDomain> = ReadonlyMap<Key, ConcreteDomain<Domain>>;
+export type ConcreteMap<Key, Domain extends AnyAbstractDomain> = ReadonlyMap<Key, ConcreteDomain<Domain>>;
 /**
  * A mapped abstract domain as mapping of keys to abstract values of an abstract domain.
  * The Bottom element is defined as empty mapping and the Top element is defined as mapping every existing key to Top.
  * @template Key       - Type of the keys of the mapping to abstract values
  * @template Domain    - Type of the abstract domain to map the keys to
  */
-export declare abstract class MappedAbstractDomain<Key, Domain extends AnyAbstractDomain> extends AbstractDomain<ConcreteMap<Key, Domain>, ReadonlyMap<Key, Domain>, ReadonlyMap<Key, Domain>, ReadonlyMap<Key, Domain>> {
+export declare class MappedAbstractDomain<Key, Domain extends AnyAbstractDomain> extends AbstractDomain<ConcreteMap<Key, Domain>, ReadonlyMap<Key, Domain>, ReadonlyMap<Key, Domain>, ReadonlyMap<Key, Domain>> {
     constructor(value: ReadonlyMap<Key, Domain>);
-    abstract create(value: ReadonlyMap<Key, Domain>): this;
+    create(value: ReadonlyMap<Key, Domain>): this;
     get(key: Key): Domain | undefined;
     has(key: Key): boolean;
-    set(key: Key, value: Domain): void;
+    protected set(key: Key, value: Domain): void;
     protected remove(key: Key): void;
     bottom(): this;
     top(): this;
@@ -31,4 +31,11 @@ export declare abstract class MappedAbstractDomain<Key, Domain extends AnyAbstra
     isBottom(): this is this;
     isValue(): this is this;
 }
-export {};
+/**
+ * A mutable version of the {@link MappedAbstractDomain} with {@link MutableMappedAbstractDomain#set|`set`} and {@link MutableMappedAbstractDomain#remove|`remove`}.
+ */
+export declare class MutableMappedAbstractDomain<Key, Domain extends AnyAbstractDomain> extends MappedAbstractDomain<Key, Domain> {
+    create(value: ReadonlyMap<Key, Domain>): this;
+    set(key: Key, value: Domain): void;
+    remove(key: Key): void;
+}

package/abstract-interpretation/domains/mapped-abstract-domain.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MappedAbstractDomain = void 0;
+exports.MutableMappedAbstractDomain = exports.MappedAbstractDomain = void 0;
 const abstract_domain_1 = require("./abstract-domain");
 const lattice_1 = require("./lattice");
 /**
@@ -13,6 +13,9 @@ class MappedAbstractDomain extends abstract_domain_1.AbstractDomain {
     constructor(value) {
         super(new Map(value));
     }
+    create(value) {
+        return new MappedAbstractDomain(value);
+    }
     get(key) {
         return this._value.get(key);
     }
@@ -122,50 +125,56 @@ class MappedAbstractDomain extends abstract_domain_1.AbstractDomain {
         return result;
     }
     concretize(limit) {
-        if (this.value.values().some(value => value.isBottom())) {
+        if (this.value.size === 0) {
             return new Set();
         }
-        let states = new Set([new Map()]);
+        let mappings = new Set([new Map()]);
         for (const [key, value] of this.value) {
             const concreteValues = value.concretize(limit);
             if (concreteValues === lattice_1.Top) {
                 return lattice_1.Top;
             }
-            const newStates = new Set();
-            for (const state of states) {
+            const newMappings = new Set();
+            for (const state of mappings) {
                 for (const concrete of concreteValues) {
-                    if (newStates.size > limit) {
+                    if (newMappings.size > limit) {
                         return lattice_1.Top;
                     }
                     const map = new Map(state);
                     map.set(key, concrete);
-                    newStates.add(map);
+                    newMappings.add(map);
                 }
             }
-            states = newStates;
+            mappings = newMappings;
         }
-        return states;
+        return mappings;
     }
     abstract(concrete) {
-        const entry = [...this.value.values()][0];
-        if (concrete === lattice_1.Top || entry === undefined) {
-            return this.create(new Map());
-        }
-        const mappings = new Map();
-        for (const state of concrete) {
-            for (const [key, value] of state) {
-                const mapping = mappings.get(key);
-                if (mapping === undefined) {
-                    mappings.set(key, new Set([value]));
+        if (concrete === lattice_1.Top) {
+            return this.top();
+        }
+        else if (concrete.size === 0) {
+            return this.bottom();
+        }
+        const domain = this.value.values().toArray()[0];
+        if (domain === undefined) {
+            return this.top();
+        }
+        const mapping = new Map();
+        for (const concreteMapping of concrete) {
+            for (const [key, value] of concreteMapping) {
+                const set = mapping.get(key);
+                if (set === undefined) {
+                    mapping.set(key, new Set([value]));
                 }
                 else {
-                    mapping.add(value);
+                    set.add(value);
                 }
             }
         }
         const result = new Map();
-        for (const [key, values] of mappings) {
-            result.set(key, entry.abstract(values));
+        for (const [key, values] of mapping) {
+            result.set(key, domain.abstract(values));
         }
         return this.create(result);
     }
@@ -176,7 +185,7 @@ class MappedAbstractDomain extends abstract_domain_1.AbstractDomain {
         return '(' + this.value.entries().toArray().map(([key, value]) => `${(0, abstract_domain_1.domainElementToString)(key)} -> ${value.toString()}`).join(', ') + ')';
     }
     isTop() {
-        return this.value.size > 0 && this.value.values().every(value => value.isTop());
+        return this.value.values().some(entry => entry.isTop());
     }
     isBottom() {
         return this.value.size === 0;
@@ -186,4 +195,19 @@ class MappedAbstractDomain extends abstract_domain_1.AbstractDomain {
     }
 }
 exports.MappedAbstractDomain = MappedAbstractDomain;
+/**
+ * A mutable version of the {@link MappedAbstractDomain} with {@link MutableMappedAbstractDomain#set|`set`} and {@link MutableMappedAbstractDomain#remove|`remove`}.
+ */
+class MutableMappedAbstractDomain extends MappedAbstractDomain {
+    create(value) {
+        return new MutableMappedAbstractDomain(value);
+    }
+    set(key, value) {
+        super.set(key, value);
+    }
+    remove(key) {
+        super.remove(key);
+    }
+}
+exports.MutableMappedAbstractDomain = MutableMappedAbstractDomain;
 //# sourceMappingURL=mapped-abstract-domain.js.map

package/abstract-interpretation/domains/state-abstract-domain.d.ts

@@ -1,5 +1,7 @@
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { AnyAbstractDomain } from './abstract-domain';
+import { Top } from './lattice';
+import type { ConcreteMap } from './mapped-abstract-domain';
 import { MappedAbstractDomain } from './mapped-abstract-domain';
 /**
  * A state abstract domain as mapping of AST node IDs of a program to abstract values of an abstract domain.
@@ -8,8 +10,35 @@ import { MappedAbstractDomain } from './mapped-abstract-domain';
  * @see {@link NodeId} for the node IDs of the AST nodes
  */
 export declare class StateAbstractDomain<Domain extends AnyAbstractDomain> extends MappedAbstractDomain<NodeId, Domain> {
+    private _isBottom;
+    constructor(value: ReadonlyMap<NodeId, Domain>, bottom?: boolean);
+    create(value: ReadonlyMap<NodeId, Domain>, bottom?: boolean): this;
+    static top<Domain extends AnyAbstractDomain>(): StateAbstractDomain<Domain>;
+    get(key: NodeId, ignoreBottom?: boolean): Domain | undefined;
+    protected set(key: NodeId, value: Domain): void;
+    bottom(): this;
+    top(): this;
+    equals(other: this): boolean;
+    leq(other: this): boolean;
+    join(other: this): this;
+    meet(other: this): this;
+    widen(other: this): this;
+    narrow(other: this): this;
+    concretize(limit: number): ReadonlySet<ConcreteMap<NodeId, Domain>> | typeof Top;
+    abstract(concrete: typeof Top | ReadonlySet<ConcreteMap<NodeId, Domain>>): this;
+    toJson(): unknown;
+    toString(): string;
+    isTop(): this is this;
+    isBottom(): this is this;
+    isValue(): this is this;
+}
+/**
+ * A mutable version of the {@link StateAbstractDomain} with {@link MutableStateAbstractDomain#set|`set`} and {@link MutableStateAbstractDomain#remove|`remove`}.
+ */
+export declare class MutableStateAbstractDomain<Domain extends AnyAbstractDomain> extends StateAbstractDomain<Domain> {
     create(value: ReadonlyMap<NodeId, Domain>): this;
-    static bottom<Domain extends AnyAbstractDomain>(): StateAbstractDomain<Domain>;
+    set(key: NodeId, value: Domain): void;
+    remove(key: NodeId): void;
 }
 /**
  * The type of the value abstract domain of a state abstract domain (i.e. the abstract domain a state abstract domain maps to).

package/abstract-interpretation/domains/state-abstract-domain.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StateAbstractDomain = void 0;
+exports.MutableStateAbstractDomain = exports.StateAbstractDomain = void 0;
+const lattice_1 = require("./lattice");
 const mapped_abstract_domain_1 = require("./mapped-abstract-domain");
 /**
  * A state abstract domain as mapping of AST node IDs of a program to abstract values of an abstract domain.
@@ -9,12 +10,137 @@ const mapped_abstract_domain_1 = require("./mapped-abstract-domain");
  * @see {@link NodeId} for the node IDs of the AST nodes
  */
 class StateAbstractDomain extends mapped_abstract_domain_1.MappedAbstractDomain {
-    create(value) {
-        return new StateAbstractDomain(value);
+    _isBottom;
+    constructor(value, bottom) {
+        super(value);
+        if (bottom || value.values().some(entry => entry.isBottom())) {
+            this._isBottom = true;
+        }
+    }
+    create(value, bottom) {
+        return new StateAbstractDomain(value, bottom ?? this._isBottom);
     }
-    static bottom() {
+    static top() {
         return new StateAbstractDomain(new Map());
     }
+    get(key, ignoreBottom) {
+        return this._isBottom && !ignoreBottom ? super.get(key)?.bottom() : super.get(key);
+    }
+    set(key, value) {
+        if (value.isBottom()) {
+            this._isBottom = true;
+        }
+        super.set(key, value);
+    }
+    bottom() {
+        return this.create(this.value, true);
+    }
+    top() {
+        return this.create(new Map());
+    }
+    equals(other) {
+        if (this._isBottom !== other._isBottom) {
+            return false;
+        }
+        return super.equals(other);
+    }
+    leq(other) {
+        if (this._isBottom) {
+            return true;
+        }
+        else if (other._isBottom) {
+            return false;
+        }
+        return super.leq(other);
+    }
+    join(other) {
+        if (this._isBottom) {
+            return other.create(other.value);
+        }
+        else if (other._isBottom) {
+            return this.create(this.value);
+        }
+        return super.join(other);
+    }
+    meet(other) {
+        const result = super.meet(other);
+        result._isBottom = this._isBottom || other._isBottom;
+        return result;
+    }
+    widen(other) {
+        if (this._isBottom) {
+            return other.create(other.value);
+        }
+        else if (other._isBottom) {
+            return this.create(this.value);
+        }
+        return super.widen(other);
+    }
+    narrow(other) {
+        const result = super.narrow(other);
+        result._isBottom = this._isBottom || other._isBottom;
+        return result;
+    }
+    concretize(limit) {
+        if (this._isBottom) {
+            return new Set();
+        }
+        else if (this.value.size === 0) {
+            return lattice_1.Top;
+        }
+        return super.concretize(limit);
+    }
+    abstract(concrete) {
+        if (concrete === lattice_1.Top) {
+            return this.top();
+        }
+        else if (concrete.size === 0) {
+            return this.create(new Map(), true);
+        }
+        return super.abstract(concrete);
+    }
+    toJson() {
+        if (this._isBottom) {
+            return lattice_1.BottomSymbol;
+        }
+        else if (this.value.size === 0) {
+            return lattice_1.TopSymbol;
+        }
+        return super.toJson();
+    }
+    toString() {
+        if (this._isBottom) {
+            return lattice_1.BottomSymbol;
+        }
+        else if (this.value.size === 0) {
+            return lattice_1.TopSymbol;
+        }
+        return super.toString();
+    }
+    isTop() {
+        return this.value.size === 0;
+    }
+    isBottom() {
+        return this._isBottom ?? false;
+    }
+    isValue() {
+        return !this._isBottom;
+    }
 }
 exports.StateAbstractDomain = StateAbstractDomain;
+/**
+ * A mutable version of the {@link StateAbstractDomain} with {@link MutableStateAbstractDomain#set|`set`} and {@link MutableStateAbstractDomain#remove|`remove`}.
+ */
+class MutableStateAbstractDomain extends StateAbstractDomain {
+    create(value) {
+        return new MutableStateAbstractDomain(value);
+    }
+    set(key, value) {
+        super.set(key, value);
+    }
+    remove(key) {
+        super.remove(key);
+    }
+}
+exports.MutableStateAbstractDomain = MutableStateAbstractDomain;
 //# sourceMappingURL=state-abstract-domain.js.map

package/control-flow/cfg-simplification.d.ts

@@ -34,6 +34,7 @@ declare function uniqueControlFlowSets(cfg: ControlFlowInformation, _info?: CfgP
 declare function toBasicBlocks(cfg: ControlFlowInformation, _info?: CfgPassInfo): ControlFlowInformation;
 /**
  * Uses {@link visitCfgInOrder} to find all nodes that are reachable from the control flow graph's {@link ControlFlowInformation.entryPoints} and returns them as a set.
+ * Please note that this will not visit the grouping delimiters of expression list!
  * @param cfg - The control flow graph whose reachable nodes to find.
  */
 export declare function cfgFindAllReachable(cfg: ControlFlowInformation): Set<NodeId>;

package/control-flow/cfg-simplification.js

@@ -59,6 +59,7 @@ function toBasicBlocks(cfg, _info) {
 }
 /**
  * Uses {@link visitCfgInOrder} to find all nodes that are reachable from the control flow graph's {@link ControlFlowInformation.entryPoints} and returns them as a set.
+ * Please note that this will not visit the grouping delimiters of expression list!
  * @param cfg - The control flow graph whose reachable nodes to find.
  */
 function cfgFindAllReachable(cfg) {

package/control-flow/extract-cfg.js

@@ -6,7 +6,6 @@ exports.extractCfgQuick = extractCfgQuick;
 exports.getCallsInCfg = getCallsInCfg;
 exports.cfg2quads = cfg2quads;
 const quads_1 = require("../util/quads");
-const fold_1 = require("../r-bridge/lang-4.x/ast/model/processing/fold");
 const r_function_call_1 = require("../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const linker_1 = require("../dataflow/internal/linker");
 const vertex_1 = require("../dataflow/graph/vertex");
@@ -14,7 +13,18 @@ const control_flow_graph_1 = require("./control-flow-graph");
 const cfg_simplification_1 = require("./cfg-simplification");
 const assert_1 = require("../util/assert");
 const built_in_1 = require("../dataflow/environments/built-in");
+const stateful_fold_1 = require("../r-bridge/lang-4.x/ast/model/processing/stateful-fold");
+const type_1 = require("../r-bridge/lang-4.x/ast/model/type");
 const cfgFolds = {
+    down: (n, down) => {
+        if (n.type === type_1.RType.FunctionDefinition) {
+            return [down[0], true];
+        }
+        else if (n.type === type_1.RType.ForLoop || n.type === type_1.RType.WhileLoop || n.type === type_1.RType.RepeatLoop) {
+            return [true, down[1]];
+        }
+        return down;
+    },
     foldNumber: cfgLeaf(control_flow_graph_1.CfgVertexType.Expression),
     foldString: cfgLeaf(control_flow_graph_1.CfgVertexType.Expression),
     foldLogical: cfgLeaf(control_flow_graph_1.CfgVertexType.Expression),
@@ -99,7 +109,7 @@ function cfgFoldProject(proj, folds) {
         return (0, control_flow_graph_1.emptyControlFlowInformation)();
     }
     else if (proj.files.length === 1) {
-        return (0, fold_1.foldAst)(proj.files[0].root, folds);
+        return (0, stateful_fold_1.foldAstStateful)(proj.files[0].root, [false, false], folds);
     }
     /* for many files, it is too expensive to keep all asts at once, hence we create and merge them incrementally */
     let exitPoints;
@@ -109,7 +119,7 @@ function cfgFoldProject(proj, folds) {
     let nexts;
     let returns;
     {
-        const firstInfo = (0, fold_1.foldAst)(proj.files[0].root, folds);
+        const firstInfo = (0, stateful_fold_1.foldAstStateful)(proj.files[0].root, [false, false], folds);
         exitPoints = firstInfo.exitPoints;
         finalGraph = firstInfo.graph;
         firstEntryPoints = firstInfo.entryPoints;
@@ -118,7 +128,7 @@ function cfgFoldProject(proj, folds) {
         returns = firstInfo.returns;
     }
     for (let i = 1; i < proj.files.length; i++) {
-        const nextInfo = (0, fold_1.foldAst)(proj.files[i].root, folds);
+        const nextInfo = (0, stateful_fold_1.foldAstStateful)(proj.files[i].root, [false, false], folds);
         finalGraph.mergeWith(nextInfo.graph);
         for (const exitPoint of exitPoints) {
             for (const entryPoint of nextInfo.entryPoints) {
@@ -147,17 +157,23 @@ function cfgLeaf(type) {
     };
 }
 const cfgLeafStatement = cfgLeaf(control_flow_graph_1.CfgVertexType.Statement);
-function cfgBreak(leaf) {
+function cfgBreak(leaf, down) {
+    if (!down[0]) {
+        return cfgLeafStatement(leaf);
+    }
     return { ...cfgLeafStatement(leaf), breaks: [leaf.info.id], exitPoints: [] };
 }
-function cfgNext(leaf) {
+function cfgNext(leaf, down) {
+    if (!down[0]) {
+        return cfgLeafStatement(leaf);
+    }
     return { ...cfgLeafStatement(leaf), nexts: [leaf.info.id], exitPoints: [] };
 }
 function cfgIgnore(_leaf) {
     return { graph: new control_flow_graph_1.ControlFlowGraph(), breaks: [], nexts: [], returns: [], exitPoints: [], entryPoints: [] };
 }
 function identifyMayStatementType(node) {
-    return node.info.role === "expr-list-child" /* RoleInParent.ExpressionListChild */ ? control_flow_graph_1.CfgVertexType.Statement : control_flow_graph_1.CfgVertexType.Expression;
+    return node.info.role === "el-c" /* RoleInParent.ExpressionListChild */ ? control_flow_graph_1.CfgVertexType.Statement : control_flow_graph_1.CfgVertexType.Expression;
 }
 function cfgIfThenElse(ifNode, condition, then, otherwise) {
     const ifId = ifNode.info.id;
@@ -318,7 +334,7 @@ function cfgFunctionDefinition(fn, params, body) {
     }
     return { graph: graph, breaks: [], nexts: [], returns: [], exitPoints: [fnId], entryPoints: [fnId] };
 }
-function cfgFunctionCall(call, name, args) {
+function cfgFunctionCall(call, name, args, down) {
     if (call.named && call.functionName.content === 'ifelse') {
         // special built-in handling for ifelse as it is an expression that does not short-circuit
         return cfgIfThenElse(call, args[0] === r_function_call_1.EmptyArgument ? (0, control_flow_graph_1.emptyControlFlowInformation)() : args[0], args[1] === r_function_call_1.EmptyArgument ? (0, control_flow_graph_1.emptyControlFlowInformation)() : args[1], args[2] === r_function_call_1.EmptyArgument ? (0, control_flow_graph_1.emptyControlFlowInformation)() : args[2]);
@@ -358,30 +374,32 @@ function cfgFunctionCall(call, name, args) {
         graph.addEdge(control_flow_graph_1.CfgVertex.toExitId(callId), exit, control_flow_graph_1.CfgEdge.makeFd());
     }
     if (call.named && call.functionName.content === 'return') {
-        info.returns.push(control_flow_graph_1.CfgVertex.toExitId(callId));
-        info.exitPoints.length = 0;
+        if (down[1]) {
+            info.returns.push(control_flow_graph_1.CfgVertex.toExitId(callId));
+            info.exitPoints.length = 0;
+        }
     }
     // should not contain any breaks, nexts, or returns, (except for the body if something like 'break()')
     return info;
 }
 exports.ResolvedCallSuffix = control_flow_graph_1.CfgVertex.toExitId('-resolved-call');
 const OriginToFoldTypeMap = {
-    [built_in_1.BuiltInProcName.IfThenElse]: (folds, call, args) => {
+    [built_in_1.BuiltInProcName.IfThenElse]: (folds, call, args, down) => {
         // arguments are in order!
         return folds.foldIfThenElse(call, // we will have to this more sophisticated if we rewrite the dfg based generation
-        args[0] === r_function_call_1.EmptyArgument ? (0, control_flow_graph_1.emptyControlFlowInformation)() : args[0], args[1] === r_function_call_1.EmptyArgument ? (0, control_flow_graph_1.emptyControlFlowInformation)() : args[1], args[2] === r_function_call_1.EmptyArgument ? (0, control_flow_graph_1.emptyControlFlowInformation)() : args[2], undefined);
+        args[0] === r_function_call_1.EmptyArgument ? (0, control_flow_graph_1.emptyControlFlowInformation)() : args[0], args[1] === r_function_call_1.EmptyArgument ? (0, control_flow_graph_1.emptyControlFlowInformation)() : args[1], args[2] === r_function_call_1.EmptyArgument ? (0, control_flow_graph_1.emptyControlFlowInformation)() : args[2], down);
     }
 };
 function cfgFunctionCallWithDataflow(graph, folds) {
-    return (call, name, args) => {
+    return (call, name, args, down) => {
         const vtx = graph.getVertex(call.info.id);
         if (vtx?.tag === vertex_1.VertexType.FunctionCall && vtx.onlyBuiltin && vtx.origin.length === 1) {
             const mayMap = OriginToFoldTypeMap[vtx.origin[0]];
             if (mayMap) {
-                return mayMap(folds, call, args, vtx);
+                return mayMap(folds, call, args, down, vtx);
             }
         }
-        const baseCfg = cfgFunctionCall(call, name, args);
+        const baseCfg = cfgFunctionCall(call, name, args, down);
         /* try to resolve the call and link the target definitions */
         const targets = (0, linker_1.getAllFunctionCallTargets)(call.info.id, graph);
         const exits = [];

package/control-flow/semantic-cfg-guided-visitor.js

@@ -279,6 +279,7 @@ class SemanticCfgGuidedVisitor extends dfg_cfg_guided_visitor_1.DataflowAwareCfg
             case built_in_1.BuiltInProcName.Recall:
                 return this.onRecallCall({ call });
             case built_in_1.BuiltInProcName.Default:
+            case built_in_1.BuiltInProcName.DefaultReadAllArgs:
             case built_in_1.BuiltInProcName.Function:
             case built_in_1.BuiltInProcName.FunctionDefinition:
                 return this.onDefaultFunctionCall({ call });

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

@@ -94,6 +94,7 @@ export interface BuiltInEvalHandlerArgs {
 }
 export type BuiltInEvalHandler = (args: BuiltInEvalHandlerArgs) => 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;
+declare function defaultBuiltInProcessorReadallArgs<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, { useAsProcessor, forceArgs }: Pick<DefaultBuiltInProcessorConfiguration, 'useAsProcessor' | 'forceArgs'>): DataflowInformation;
 /**
  * This contains all names of built-in function handlers and origins
  */
@@ -110,6 +111,8 @@ export declare enum BuiltInProcName {
     Break = "builtin:break",
     /** the default built-in processor, see {@link defaultBuiltInProcessor} */
     Default = "builtin:default",
+    /** Just a more performant variant of the default processor for built-ins that need to read all their arguments, see {@link defaultBuiltInProcessor}, this will still produce the origin `BuiltIn.Default` */
+    DefaultReadAllArgs = "builtin:default-read-all-args",
     /** for `eval` calls, see {@link processEvalCall} */
     Eval = "builtin:eval",
     /** for expression lists, see {@link processExpressionList} */
@@ -181,6 +184,7 @@ export declare const BuiltInProcessorMapper: {
     readonly "builtin:assignment": typeof processAssignment;
     readonly "builtin:assignment-like": typeof processAssignmentLike;
     readonly "builtin:default": typeof defaultBuiltInProcessor;
+    readonly "builtin:default-read-all-args": typeof defaultBuiltInProcessorReadallArgs;
     readonly "builtin:eval": typeof processEvalCall;
     readonly "builtin:expression-list": typeof processExpressionList;
     readonly "builtin:for-loop": typeof processForLoop;

package/dataflow/environments/built-in.js

@@ -60,11 +60,10 @@ const builtInPrefixLength = 'built-in:'.length;
 function dropBuiltInPrefix(name) {
     return name.slice(builtInPrefixLength);
 }
-function defaultBuiltInProcessor(name, args, rootId, data, { returnsNthArgument, useAsProcessor, forceArgs, readAllArguments, cfg, hasUnknownSideEffects, treatAsFnCall }) {
-    const activeProcessor = useAsProcessor ?? BuiltInProcName.Default;
-    const { information: res, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs, origin: activeProcessor });
+function defaultBuiltInProcessor(name, args, rootId, data, { returnsNthArgument, useAsProcessor = BuiltInProcName.Default, forceArgs, readAllArguments, cfg, hasUnknownSideEffects, treatAsFnCall }) {
+    const { information: res, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs, origin: useAsProcessor });
     if (returnsNthArgument !== undefined) {
-        const arg = returnsNthArgument === 'last' ? processedArguments[args.length - 1] : processedArguments[returnsNthArgument];
+        const arg = returnsNthArgument === 'last' ? processedArguments.at(-1) : processedArguments[returnsNthArgument];
         if (arg !== undefined) {
             res.graph.addEdge(rootId, arg.entryPoint, edge_1.EdgeType.Returns);
         }
@@ -110,7 +109,7 @@ function defaultBuiltInProcessor(name, args, rootId, data, { returnsNthArgument,
                     environment: data.environment,
                     onlyBuiltin: false,
                     cds: data.cds,
-                    origin: [activeProcessor]
+                    origin: [useAsProcessor]
                 });
             }
         }
@@ -120,6 +119,16 @@ function defaultBuiltInProcessor(name, args, rootId, data, { returnsNthArgument,
     }
     return res;
 }
+function defaultBuiltInProcessorReadallArgs(name, args, rootId, data, { useAsProcessor = BuiltInProcName.Default, forceArgs }) {
+    const { information: res, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs, origin: useAsProcessor });
+    const g = res.graph;
+    for (const arg of processedArguments) {
+        if (arg) {
+            g.addEdge(rootId, arg.entryPoint, edge_1.EdgeType.Reads);
+        }
+    }
+    return res;
+}
 /**
  * This contains all names of built-in function handlers and origins
  */
@@ -137,6 +146,8 @@ var BuiltInProcName;
     BuiltInProcName["Break"] = "builtin:break";
     /** the default built-in processor, see {@link defaultBuiltInProcessor} */
     BuiltInProcName["Default"] = "builtin:default";
+    /** Just a more performant variant of the default processor for built-ins that need to read all their arguments, see {@link defaultBuiltInProcessor}, this will still produce the origin `BuiltIn.Default` */
+    BuiltInProcName["DefaultReadAllArgs"] = "builtin:default-read-all-args";
     /** for `eval` calls, see {@link processEvalCall} */
     BuiltInProcName["Eval"] = "builtin:eval";
     /** for expression lists, see {@link processExpressionList} */
@@ -208,6 +219,7 @@ exports.BuiltInProcessorMapper = {
     [BuiltInProcName.Assignment]: built_in_assignment_1.processAssignment,
     [BuiltInProcName.AssignmentLike]: built_in_assignment_1.processAssignmentLike,
     [BuiltInProcName.Default]: defaultBuiltInProcessor,
+    [BuiltInProcName.DefaultReadAllArgs]: defaultBuiltInProcessorReadallArgs,
     [BuiltInProcName.Eval]: built_in_eval_1.processEvalCall,
     [BuiltInProcName.ExpressionList]: built_in_expression_list_1.processExpressionList,
     [BuiltInProcName.ForLoop]: built_in_for_loop_1.processForLoop,

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

@@ -36,18 +36,14 @@ export declare const DefaultBuiltinConfig: [{
 }, {
     readonly type: "function";
     readonly names: ["~", "+", "-", "*", "/", "^", "!", "?", "**", "==", "!=", ">", "<", ">=", "<=", "%%", "%/%", "%*%", "%in%", ":", "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", "is.null", "numeric", "as.character", "as.integer", "as.logical", "as.numeric", "as.matrix", "rbind", "nrow", "ncol", "tryCatch", "expression", "factor", "missing", "as.data.frame", "data.frame", "na.omit", "rownames", "names", "order", "length", "any", "dim", "matrix", "cbind", "nchar", "pdf", "jpeg", "png", "windows", "postscript", "xfig", "bitmap", "pictex", "cairo_pdf", "svg", "bmp", "tiff", "X11", "quartz", "jitter"];
-    readonly processor: BuiltInProcName.Default;
-    readonly config: {
-        readonly readAllArguments: true;
-    };
+    readonly processor: BuiltInProcName.DefaultReadAllArgs;
+    readonly config: {};
     readonly assumePrimitive: true;
 }, {
     readonly type: "function";
     readonly names: ["t", "aperm"];
-    readonly processor: BuiltInProcName.Default;
-    readonly config: {
-        readonly readAllArguments: true;
-    };
+    readonly processor: BuiltInProcName.DefaultReadAllArgs;
+    readonly config: {};
     readonly assumePrimitive: false;
 }, {
     readonly type: "function";