@eagleoutice/flowr 2.10.1 → 2.10.2

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

@@ -1,130 +1,231 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MutableStateAbstractDomain = exports.StateAbstractDomain = void 0;
+const abstract_domain_1 = require("./abstract-domain");
 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.
- * The Bottom element is defined as empty mapping and the Top element is defined as mapping every existing mapped AST node ID to Top.
- * @template Domain - Type of the abstract domain to map the AST node IDs to
+ * A state abstract domain that maps AST node IDs of a program to abstract values of an abstract domain.
+ * The Bottom element is defined as {@link Bottom} symbol and the Top element as empty mapping.
+ * @template Domain - Type of the value abstract domain to map the AST node IDs to
  * @see {@link NodeId} for the node IDs of the AST nodes
  */
-class StateAbstractDomain extends mapped_abstract_domain_1.MappedAbstractDomain {
-    _isBottom;
-    constructor(value, bottom) {
-        super(value);
-        if (bottom || value.values().some(entry => entry.isBottom())) {
-            this._isBottom = true;
+class StateAbstractDomain extends abstract_domain_1.AbstractDomain {
+    domain;
+    constructor(value, domain) {
+        if (value === lattice_1.Bottom || value.values().some(entry => entry.isBottom())) {
+            super(lattice_1.Bottom);
         }
+        else {
+            super(new Map(value));
+        }
+        this.domain = domain;
+    }
+    create(value) {
+        return new StateAbstractDomain(value, this.domain);
+    }
+    static top(domain) {
+        return new StateAbstractDomain(new Map(), domain);
     }
-    create(value, bottom) {
-        return new StateAbstractDomain(value, bottom ?? this._isBottom);
+    static bottom(domain) {
+        return new StateAbstractDomain(lattice_1.Bottom, domain);
     }
-    static top() {
-        return new StateAbstractDomain(new Map());
+    get(key) {
+        return this.value === lattice_1.Bottom ? this.domain.bottom() : this.value.get(key);
     }
-    get(key, ignoreBottom) {
-        return this._isBottom && !ignoreBottom ? super.get(key)?.bottom() : super.get(key);
+    has(key) {
+        return this.value !== lattice_1.Bottom && this.value.has(key);
     }
     set(key, value) {
-        if (value.isBottom()) {
-            this._isBottom = true;
+        if (this.value === lattice_1.Bottom) {
+            this._value = new Map();
         }
-        super.set(key, value);
+        this._value.set(key, value);
     }
-    bottom() {
-        return this.create(this.value, true);
+    remove(key) {
+        if (this.value !== lattice_1.Bottom) {
+            this._value.delete(key);
+        }
     }
     top() {
-        return this.create(new Map());
+        return StateAbstractDomain.top(this.domain);
+    }
+    bottom() {
+        return StateAbstractDomain.bottom(this.domain);
     }
     equals(other) {
-        if (this._isBottom !== other._isBottom) {
+        if (this.value === other.value) {
+            return true;
+        }
+        else if (this.value === lattice_1.Bottom || other.value === lattice_1.Bottom || this.value.size !== other.value.size) {
             return false;
         }
-        return super.equals(other);
+        for (const [key, value] of this.value.entries()) {
+            const otherValue = other.get(key);
+            if (otherValue === undefined || !value.equals(otherValue)) {
+                return false;
+            }
+        }
+        return true;
     }
     leq(other) {
-        if (this._isBottom) {
+        if (this.value === other.value || this.value === lattice_1.Bottom) {
             return true;
         }
-        else if (other._isBottom) {
+        else if (other.value === lattice_1.Bottom || this.value.size > other.value.size) {
             return false;
         }
-        return super.leq(other);
+        for (const [key, value] of this.value.entries()) {
+            const otherValue = other.get(key);
+            if (otherValue === undefined || !value.leq(otherValue)) {
+                return false;
+            }
+        }
+        return true;
     }
     join(other) {
-        if (this._isBottom) {
-            return other.create(other.value);
+        if (this.value === lattice_1.Bottom) {
+            return this.create(other.value);
         }
-        else if (other._isBottom) {
+        else if (other.value === lattice_1.Bottom) {
             return this.create(this.value);
         }
-        return super.join(other);
+        const result = this.create(this.value);
+        for (const [key, value] of other.value.entries()) {
+            const currValue = result.get(key);
+            if (currValue === undefined) {
+                result.set(key, value);
+            }
+            else {
+                result.set(key, currValue.join(value));
+            }
+        }
+        return result;
     }
     meet(other) {
-        const result = super.meet(other);
-        result._isBottom = this._isBottom || other._isBottom;
+        if (this.value === lattice_1.Bottom || other.value === lattice_1.Bottom) {
+            return this.bottom();
+        }
+        const result = this.create(this.value);
+        for (const key of result.value.keys()) {
+            if (!other.has(key)) {
+                result.remove(key);
+            }
+        }
+        for (const [key, value] of other.value.entries()) {
+            const currValue = result.get(key);
+            if (currValue !== undefined) {
+                result.set(key, currValue.meet(value));
+            }
+        }
         return result;
     }
     widen(other) {
-        if (this._isBottom) {
-            return other.create(other.value);
+        if (this.value === lattice_1.Bottom) {
+            return this.create(other.value);
         }
-        else if (other._isBottom) {
+        else if (other.value === lattice_1.Bottom) {
             return this.create(this.value);
         }
-        return super.widen(other);
+        const result = this.create(this.value);
+        for (const [key, value] of other.value.entries()) {
+            const currValue = result.get(key);
+            if (currValue === undefined) {
+                result.set(key, value);
+            }
+            else {
+                result.set(key, currValue.widen(value));
+            }
+        }
+        return result;
     }
     narrow(other) {
-        const result = super.narrow(other);
-        result._isBottom = this._isBottom || other._isBottom;
+        if (this.value === lattice_1.Bottom || other.value === lattice_1.Bottom) {
+            return this.bottom();
+        }
+        const result = this.create(this.value);
+        for (const key of result.value.keys()) {
+            if (!other.has(key)) {
+                result.remove(key);
+            }
+        }
+        for (const [key, value] of other.value.entries()) {
+            const currValue = result.get(key);
+            if (currValue !== undefined) {
+                result.set(key, currValue.narrow(value));
+            }
+        }
         return result;
     }
     concretize(limit) {
-        if (this._isBottom) {
+        if (this.value === lattice_1.Bottom) {
             return new Set();
         }
-        else if (this.value.size === 0) {
-            return lattice_1.Top;
-        }
-        return super.concretize(limit);
+        let mappings = new Set([new Map()]);
+        for (const [key, value] of this.value.entries()) {
+            const concreteValues = value.concretize(limit);
+            if (concreteValues === lattice_1.Top) {
+                return lattice_1.Top;
+            }
+            const newMappings = new Set();
+            for (const state of mappings) {
+                for (const concrete of concreteValues) {
+                    if (newMappings.size > limit) {
+                        return lattice_1.Top;
+                    }
+                    const map = new Map(state);
+                    map.set(key, concrete);
+                    newMappings.add(map);
+                }
+            }
+            mappings = newMappings;
+        }
+        return mappings;
     }
     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);
+            return this.bottom();
+        }
+        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 {
+                    set.add(value);
+                }
+            }
+        }
+        const result = new Map();
+        for (const [key, values] of mapping) {
+            result.set(key, this.domain.abstract(values));
+        }
+        return this.create(result);
     }
     toJson() {
-        if (this._isBottom) {
-            return lattice_1.BottomSymbol;
-        }
-        else if (this.value.size === 0) {
-            return lattice_1.TopSymbol;
+        if (this.value === lattice_1.Bottom) {
+            return this.value.description;
         }
-        return super.toJson();
+        return Object.fromEntries(this.value.entries().map(([key, value]) => [key, value.toJson()]));
     }
     toString() {
-        if (this._isBottom) {
+        if (this.value === lattice_1.Bottom) {
             return lattice_1.BottomSymbol;
         }
-        else if (this.value.size === 0) {
-            return lattice_1.TopSymbol;
-        }
-        return super.toString();
+        return '(' + this.value.entries().toArray().map(([key, value]) => `${(0, abstract_domain_1.domainElementToString)(key)} -> ${value.toString()}`).join(', ') + ')';
     }
     isTop() {
-        return this.value.size === 0;
+        return this.value !== lattice_1.Bottom && this.value.size === 0;
     }
     isBottom() {
-        return this._isBottom ?? false;
+        return this.value == lattice_1.Bottom;
     }
     isValue() {
-        return !this._isBottom;
+        return this.value !== lattice_1.Bottom;
     }
 }
 exports.StateAbstractDomain = StateAbstractDomain;
@@ -133,7 +234,13 @@ exports.StateAbstractDomain = StateAbstractDomain;
  */
 class MutableStateAbstractDomain extends StateAbstractDomain {
     create(value) {
-        return new MutableStateAbstractDomain(value);
+        return new MutableStateAbstractDomain(value, this.domain);
+    }
+    static top(domain) {
+        return new MutableStateAbstractDomain(new Map(), domain);
+    }
+    static bottom(domain) {
+        return new MutableStateAbstractDomain(lattice_1.Bottom, domain);
     }
     set(key, value) {
         super.set(key, value);

package/abstract-interpretation/unsupported-functions.d.ts

@@ -0,0 +1,10 @@
+import { type DataflowGraphVertexArgument } from '../dataflow/graph/vertex';
+/**
+ * Helper for unsupported functions that may change the environment.
+ */
+export declare const UnsupportedFunctions: {
+    /**
+     * Checks whether a data flow graph vertex represents a unsupported (environment-changing) function call (e.g. `eval`, `load`, `attach`, `rm`, ...)
+     */
+    isUnsupportedCall(this: void, vertex: DataflowGraphVertexArgument | undefined): boolean;
+};

package/abstract-interpretation/unsupported-functions.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsupportedFunctions = void 0;
+const identifier_1 = require("../dataflow/environments/identifier");
+const vertex_1 = require("../dataflow/graph/vertex");
+/**
+ * List of known function calls that may change the environment unresolvable/implicitly.
+ */
+const UnsupportedFunctionsList = {
+    '.Primitive': { package: 'base' },
+    '.Internal': { package: 'base' },
+    '.External': { package: 'base' },
+    '.Call': { package: 'base' },
+    '.C': { package: 'base' },
+    '.Fortran': { package: 'base' },
+    '.dyn.load': { package: 'base' },
+    'eval': { package: 'base' },
+    'evalq': { package: 'base' },
+    'eval.parent': { package: 'base' },
+    'eval_tidy': { package: 'rlang' },
+    'eval_bare': { package: 'rlang' },
+    'body<-': { package: 'base' },
+    'formals<-': { package: 'base' },
+    'environment<-': { package: 'base' },
+    'load': { package: 'base' },
+    'attach': { package: 'base' },
+    'detach': { package: 'base' },
+    'rm': { package: 'base' },
+    'remove': { package: 'base' },
+    'list2env': { package: 'base' },
+    'assignInNamespace': { package: 'utils' },
+    'assignInMyNamespace': { package: 'utils' },
+};
+/**
+ * Helper for unsupported functions that may change the environment.
+ */
+exports.UnsupportedFunctions = {
+    /**
+     * Checks whether a data flow graph vertex represents a unsupported (environment-changing) function call (e.g. `eval`, `load`, `attach`, `rm`, ...)
+     */
+    isUnsupportedCall(vertex) {
+        return (0, vertex_1.isFunctionCallVertex)(vertex) && Object.hasOwn(UnsupportedFunctionsList, identifier_1.Identifier.getName(vertex.name));
+    }
+};
+//# sourceMappingURL=unsupported-functions.js.map

package/benchmark/slicer.js

@@ -26,7 +26,6 @@ const arrays_1 = require("../util/collections/arrays");
 const config_1 = require("../config");
 const extract_cfg_1 = require("../control-flow/extract-cfg");
 const shape_inference_1 = require("../abstract-interpretation/data-frame/shape-inference");
-const lattice_1 = require("../abstract-interpretation/domains/lattice");
 const set_range_domain_1 = require("../abstract-interpretation/domains/set-range-domain");
 const fs_1 = __importDefault(require("fs"));
 const flowr_analyzer_context_1 = require("../project/context/flowr-analyzer-context");
@@ -269,9 +268,9 @@ class BenchmarkSlicer {
         const inference = new shape_inference_1.DataFrameShapeInferenceVisitor({ controlFlow: cfinfo, dfg, normalizedAst: ast, ctx: this.context });
         this.measureSimpleStep('infer data frame shapes', () => inference.start());
         const result = inference.getEndState();
-        stats.numberOfResultConstraints = result.value.size;
-        stats.sizeOfInfo = (0, size_of_1.safeSizeOf)([inference.getAbstractTrace()]);
-        for (const value of result.value.values()) {
+        stats.numberOfResultConstraints = result.isValue() ? result.value.size : 0;
+        stats.sizeOfInfo = (0, size_of_1.safeSizeOf)(inference.getAbstractTrace().entries().toArray());
+        for (const value of result.isValue() ? result.value.values() : []) {
             if (value.isTop()) {
                 stats.numberOfResultingTop++;
             }
@@ -290,8 +289,9 @@ class BenchmarkSlicer {
                 stats.numberOfEmptyNodes++;
                 return;
             }
+            const state = inference.getAbstractState(node.info.id);
             const nodeStats = {
-                numberOfEntries: inference.getAbstractState(node.info.id)?.value.size ?? 0
+                numberOfEntries: state?.isValue() ? state.value.size : 0
             };
             if (operations !== undefined) {
                 nodeStats.mappedOperations = operations.map(op => op.operation);
@@ -322,7 +322,7 @@ class BenchmarkSlicer {
     getInferredRange(value) {
         if (value.isValue()) {
             if (value instanceof set_range_domain_1.SetRangeDomain) {
-                return value.value.range === lattice_1.Top ? Infinity : value.value.range.size;
+                return value.isFinite() ? value.value.range.size : Infinity;
             }
             else {
                 return value.value[1] - value.value[0];
@@ -335,16 +335,13 @@ class BenchmarkSlicer {
             return 'top';
         }
         else if (value.isValue()) {
-            if (value instanceof set_range_domain_1.SetRangeDomain) {
-                if (value.value.range === lattice_1.Top) {
-                    return 'infinite';
-                }
+            if (!value.isFinite()) {
+                return 'infinite';
+            }
+            else if (value instanceof set_range_domain_1.SetRangeDomain) {
                 return Math.floor(value.value.min.size + (value.value.range.size / 2));
             }
             else {
-                if (!isFinite(value.value[1])) {
-                    return 'infinite';
-                }
                 return Math.floor((value.value[0] + value.value[1]) / 2);
             }
         }

package/cli/flowr.js

@@ -140,7 +140,7 @@ async function mainRepl() {
         await (0, print_version_1.printVersionRepl)(defaultEngine);
         const w = (x) => ansi_1.ansiFormatter.format(x, { color: 7 /* Colors.White */, effect: ansi_1.ColorEffect.Foreground, style: 3 /* FontStyles.Italic */ });
         console.log(w('use ') + ansi_1.ansiFormatter.format(':help', { color: 7 /* Colors.White */, effect: ansi_1.ColorEffect.Foreground, style: 1 /* FontStyles.Bold */ }) + w(' to get a list of available commands.'));
-        await (0, core_1.repl)({ analyzer: analyzer, allowRSessionAccess });
+        await (0, core_1.repl)({ analyzer, allowRSessionAccess });
     }
     process.exit(0);
 }

package/control-flow/control-flow-graph.js

@@ -589,16 +589,20 @@ class ControlFlowGraph {
      * @see {@link ControlFlowGraph#addEdges|addEdges()} - to add multiple edges at once
      */
     addEdge(from, to, edge) {
-        const edgesFrom = this.edgeInfos.get(from) ?? new Map();
-        if (!this.edgeInfos.has(from)) {
-            this.edgeInfos.set(from, edgesFrom);
+        const edgesFrom = this.edgeInfos.get(from);
+        if (!edgesFrom) {
+            this.edgeInfos.set(from, new Map([[to, edge]]));
+        }
+        else {
+            edgesFrom.set(to, edge);
         }
-        edgesFrom.set(to, edge);
-        const edgesTo = this.revEdgeInfos.get(to) ?? new Map();
-        if (!this.revEdgeInfos.has(to)) {
-            this.revEdgeInfos.set(to, edgesTo);
+        const edgesTo = this.revEdgeInfos.get(to);
+        if (!edgesTo) {
+            this.revEdgeInfos.set(to, new Map([[from, edge]]));
+        }
+        else {
+            edgesTo.set(from, edge);
         }
-        edgesTo.set(from, edge);
         return this;
     }
     /**
@@ -762,7 +766,7 @@ class ControlFlowGraph {
         const roots = other.roots;
         if (this._mayBB) {
             for (const [id, node] of other.vtxInfos) {
-                this.addVertex(node, forceNested ? false : roots.has(id));
+                this.addVertex(node, !forceNested && roots.has(id));
             }
         }
         else {

package/control-flow/semantic-cfg-guided-visitor.d.ts

@@ -566,4 +566,10 @@ export declare class SemanticCfgGuidedVisitor<OtherInfo = NoInfo, ControlFlow ex
     protected onRecallCall(_data: {
         call: DataflowGraphVertexFunctionCall;
     }): void;
+    /**
+     * This event triggers for any purr formula as in `map(df, ~ .x + 1)`
+     */
+    protected onPurrFormulaCall(_data: {
+        call: DataflowGraphVertexFunctionCall;
+    }): void;
 }

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

@@ -278,6 +278,8 @@ class SemanticCfgGuidedVisitor extends dfg_cfg_guided_visitor_1.DataflowAwareCfg
                 return this.onUnnamedCall({ call });
             case built_in_proc_name_1.BuiltInProcName.Recall:
                 return this.onRecallCall({ call });
+            case built_in_proc_name_1.BuiltInProcName.PurrrFormula:
+                return this.onPurrFormulaCall({ call });
             case built_in_proc_name_1.BuiltInProcName.Default:
             case built_in_proc_name_1.BuiltInProcName.DefaultReadAllArgs:
             case built_in_proc_name_1.BuiltInProcName.Function:
@@ -640,6 +642,10 @@ class SemanticCfgGuidedVisitor extends dfg_cfg_guided_visitor_1.DataflowAwareCfg
      * @protected
      */
     onRecallCall(_data) { }
+    /**
+     * This event triggers for any purr formula as in `map(df, ~ .x + 1)`
+     */
+    onPurrFormulaCall(_data) { }
 }
 exports.SemanticCfgGuidedVisitor = SemanticCfgGuidedVisitor;
 //# sourceMappingURL=semantic-cfg-guided-visitor.js.map

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

@@ -38,6 +38,12 @@ export declare enum BuiltInProcName {
     Local = "builtin:local",
     /** for the pipe operators, see {@link processPipe} */
     Pipe = "builtin:pipe",
+    /**
+     * Support for purrr's functional style of formulas with implicit arguments,
+     * for example, supports `map(g, ~ .x + 2)`
+     * @see {@link processPurrrFormula}
+     */
+    PurrrFormula = "builtin:purrr-formula",
     /** for `quote`, and other substituting calls, see {@link processQuote} */
     Quote = "builtin:quote",
     /**

package/dataflow/environments/built-in-proc-name.js

@@ -42,6 +42,12 @@ var BuiltInProcName;
     BuiltInProcName["Local"] = "builtin:local";
     /** for the pipe operators, see {@link processPipe} */
     BuiltInProcName["Pipe"] = "builtin:pipe";
+    /**
+     * Support for purrr's functional style of formulas with implicit arguments,
+     * for example, supports `map(g, ~ .x + 2)`
+     * @see {@link processPurrrFormula}
+     */
+    BuiltInProcName["PurrrFormula"] = "builtin:purrr-formula";
     /** for `quote`, and other substituting calls, see {@link processQuote} */
     BuiltInProcName["Quote"] = "builtin:quote";
     /**

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

@@ -15,7 +15,7 @@ import { processFunctionDefinition } from '../internal/process/functions/call/bu
 import { processExpressionList } from '../internal/process/functions/call/built-in/built-in-expression-list';
 import { processGet } from '../internal/process/functions/call/built-in/built-in-get';
 import type { AstIdMap, ParentInformation, RNodeWithParent } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import { type RFunctionArgument } from '../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import { type PotentiallyEmptyRArgument } from '../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import { RSymbol } from '../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import { type BuiltIn, NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { processLibrary } from '../internal/process/functions/call/built-in/built-in-library';
@@ -43,8 +43,9 @@ import { processRecall } from '../internal/process/functions/call/built-in/built
 import { processS7NewGeneric } from '../internal/process/functions/call/built-in/built-in-s-seven-new-generic';
 import { processS7Dispatch } from '../internal/process/functions/call/built-in/built-in-s-seven-dispatch';
 import { BuiltInProcName } from './built-in-proc-name';
-export type BuiltInIdentifierProcessor = <OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>) => DataflowInformation;
-export type BuiltInIdentifierProcessorWithConfig<Config> = <OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: Config) => DataflowInformation;
+import { processPurrrFormula } from '../internal/process/functions/call/built-in/built-in-purrr-formula';
+export type BuiltInIdentifierProcessor = <OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>) => DataflowInformation;
+export type BuiltInIdentifierProcessorWithConfig<Config> = <OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: Config) => DataflowInformation;
 export interface BuiltInIdentifierDefinition extends IdentifierReference {
     type: ReferenceType.BuiltInFunction;
     definedAt: BuiltIn;
@@ -81,8 +82,8 @@ export interface BuiltInEvalHandlerArgs {
     blocked?: Set<NodeId>;
 }
 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;
+declare function defaultBuiltInProcessor<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly PotentiallyEmptyRArgument<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 PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, { useAsProcessor, forceArgs }: Pick<DefaultBuiltInProcessorConfiguration, 'useAsProcessor' | 'forceArgs'>): DataflowInformation;
 export declare const BuiltInProcessorMapper: {
     readonly "builtin:access": typeof processAccess;
     readonly "builtin:apply": typeof processApply;
@@ -100,6 +101,7 @@ export declare const BuiltInProcessorMapper: {
     readonly "builtin:list": typeof processList;
     readonly "builtin:local": typeof processLocal;
     readonly "builtin:pipe": typeof processPipe;
+    readonly "builtin:purrr-formula": typeof processPurrrFormula;
     readonly "builtin:quote": typeof processQuote;
     readonly "builtin:recall": typeof processRecall;
     readonly "builtin:register-hook": typeof processRegisterHook;

package/dataflow/environments/built-in.js

@@ -41,6 +41,7 @@ const built_in_s_seven_new_generic_1 = require("../internal/process/functions/ca
 const built_in_s_seven_dispatch_1 = require("../internal/process/functions/call/built-in/built-in-s-seven-dispatch");
 const r_string_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-string");
 const built_in_proc_name_1 = require("./built-in-proc-name");
+const built_in_purrr_formula_1 = require("../internal/process/functions/call/built-in/built-in-purrr-formula");
 function defaultBuiltInProcessor(name, args, rootId, data, { returnsNthArgument, useAsProcessor = built_in_proc_name_1.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) {
@@ -127,6 +128,7 @@ exports.BuiltInProcessorMapper = {
     [built_in_proc_name_1.BuiltInProcName.List]: built_in_list_1.processList,
     [built_in_proc_name_1.BuiltInProcName.Local]: built_in_local_1.processLocal,
     [built_in_proc_name_1.BuiltInProcName.Pipe]: built_in_pipe_1.processPipe,
+    [built_in_proc_name_1.BuiltInProcName.PurrrFormula]: built_in_purrr_formula_1.processPurrrFormula,
     [built_in_proc_name_1.BuiltInProcName.Quote]: built_in_quote_1.processQuote,
     [built_in_proc_name_1.BuiltInProcName.Recall]: built_in_recall_1.processRecall,
     [built_in_proc_name_1.BuiltInProcName.RegisterHook]: built_in_register_hook_1.processRegisterHook,