@eagleoutice/flowr 2.2.11 → 2.2.13

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

@@ -0,0 +1,128 @@
+import type { CfgExpressionVertex, CfgStatementVertex, ControlFlowInformation } from './control-flow-graph';
+import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { BasicCfgGuidedVisitorConfiguration } from './basic-cfg-guided-visitor';
+import { BasicCfgGuidedVisitor } from './basic-cfg-guided-visitor';
+import type { RAccess } from '../r-bridge/lang-4.x/ast/model/nodes/r-access';
+import type { RArgument } from '../r-bridge/lang-4.x/ast/model/nodes/r-argument';
+import type { RBinaryOp } from '../r-bridge/lang-4.x/ast/model/nodes/r-binary-op';
+import type { RExpressionList } from '../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
+import type { RForLoop } from '../r-bridge/lang-4.x/ast/model/nodes/r-for-loop';
+import type { RFunctionCall } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import type { RFunctionDefinition } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-definition';
+import type { RIfThenElse } from '../r-bridge/lang-4.x/ast/model/nodes/r-if-then-else';
+import type { RParameter } from '../r-bridge/lang-4.x/ast/model/nodes/r-parameter';
+import type { RPipe } from '../r-bridge/lang-4.x/ast/model/nodes/r-pipe';
+import type { RRepeatLoop } from '../r-bridge/lang-4.x/ast/model/nodes/r-repeat-loop';
+import type { RUnaryOp } from '../r-bridge/lang-4.x/ast/model/nodes/r-unary-op';
+import type { RWhileLoop } from '../r-bridge/lang-4.x/ast/model/nodes/r-while-loop';
+import type { RBreak } from '../r-bridge/lang-4.x/ast/model/nodes/r-break';
+import type { RComment } from '../r-bridge/lang-4.x/ast/model/nodes/r-comment';
+import type { RLineDirective } from '../r-bridge/lang-4.x/ast/model/nodes/r-line-directive';
+import type { RLogical } from '../r-bridge/lang-4.x/ast/model/nodes/r-logical';
+import type { RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
+import type { RNext } from '../r-bridge/lang-4.x/ast/model/nodes/r-next';
+import type { RNumber } from '../r-bridge/lang-4.x/ast/model/nodes/r-number';
+import type { RSymbol } from '../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
+import type { NoInfo, RNode } from '../r-bridge/lang-4.x/ast/model/model';
+export interface SyntaxCfgGuidedVisitorConfiguration<OtherInfo = NoInfo, Cfg extends ControlFlowInformation = ControlFlowInformation, Ast extends NormalizedAst<OtherInfo> = NormalizedAst<OtherInfo>> extends BasicCfgGuidedVisitorConfiguration<Cfg> {
+    readonly normalizedAst: Ast;
+}
+/**
+ * This visitor extends on the {@link BasicCfgGuidedVisitor} by dispatching visitors based on the AST type of the node.
+ *
+ * Use {@link BasicCfgGuidedVisitor#start} to start the traversal.
+ */
+export declare class SyntaxAwareCfgGuidedVisitor<OtherInfo = NoInfo, Cfg extends ControlFlowInformation = ControlFlowInformation, Ast extends NormalizedAst<OtherInfo> = NormalizedAst<OtherInfo>, Config extends SyntaxCfgGuidedVisitorConfiguration<OtherInfo, Cfg, Ast> = SyntaxCfgGuidedVisitorConfiguration<OtherInfo, Cfg, Ast>> extends BasicCfgGuidedVisitor<Cfg, Config> {
+    /**
+     * Get the normalized AST node for the given id or fail if it does not exist.
+     */
+    protected getNormalizedAst(id: NodeId): RNode<OtherInfo & ParentInformation> | undefined;
+    protected onStatementNode(node: CfgStatementVertex): void;
+    protected onExpressionNode(node: CfgExpressionVertex): void;
+    private onExprOrStmtNode;
+    /**
+     * {@link RAccess}
+     */
+    protected visitRAccess(_node: RAccess<OtherInfo & ParentInformation>): void;
+    /**
+     * {@link RArgument}
+     */
+    protected visitRArgument(_node: RArgument<OtherInfo & ParentInformation>): void;
+    /**
+     * {@link RBinaryOp}
+     */
+    protected visitRBinaryOp(_node: RBinaryOp<OtherInfo & ParentInformation>): void;
+    /**
+     * {@link RExpressionList}
+     */
+    protected visitRExpressionList(_node: RExpressionList<OtherInfo & ParentInformation>): void;
+    /**
+     * {@link RForLoop}
+     */
+    protected visitRForLoop(_node: RForLoop<OtherInfo & ParentInformation>): void;
+    /**
+     * {@link RFunctionCall}
+     */
+    protected visitRFunctionCall(_node: RFunctionCall<OtherInfo & ParentInformation>): void;
+    /**
+     * {@link RFunctionDefinition}
+     */
+    protected visitRFunctionDefinition(_node: RFunctionDefinition<OtherInfo & ParentInformation>): void;
+    /**
+     * {@link RIfThenElse}
+     */
+    protected visitRIfThenElse(_node: RIfThenElse<OtherInfo & ParentInformation>): void;
+    /**
+     * {@link RParameter}
+     */
+    protected visitRParameter(_node: RParameter<OtherInfo & ParentInformation>): void;
+    /**
+     * {@link RPipe}
+     */
+    protected visitRPipe(_node: RPipe<OtherInfo & ParentInformation>): void;
+    /**
+     * {@link RRepeatLoop}
+     */
+    protected visitRRepeatLoop(_node: RRepeatLoop<OtherInfo & ParentInformation>): void;
+    /**
+     * {@link RUnaryOp}
+     */
+    protected visitRUnaryOp(_node: RUnaryOp<OtherInfo & ParentInformation>): void;
+    /**
+     * {@link RWhileLoop}
+     */
+    protected visitRWhileLoop(_node: RWhileLoop<OtherInfo & ParentInformation>): void;
+    /**
+     * {@link RBreak}
+     */
+    protected visitRBreak(_node: RBreak<OtherInfo & ParentInformation>): void;
+    /**
+     * {@link RComment}
+     */
+    protected visitRComment(_node: RComment<OtherInfo & ParentInformation>): void;
+    /**
+     * {@link RLineDirective}
+     */
+    protected visitRLineDirective(_node: RLineDirective<OtherInfo & ParentInformation>): void;
+    /**
+     * {@link RLogical}
+     */
+    protected visitRLogical(_node: RLogical<OtherInfo & ParentInformation>): void;
+    /**
+     * {@link RNext}
+     */
+    protected visitRNext(_node: RNext<OtherInfo & ParentInformation>): void;
+    /**
+     * {@link RNumber}
+     */
+    protected visitRNumber(_node: RNumber<OtherInfo & ParentInformation>): void;
+    /**
+     * {@link RString}
+     */
+    protected visitRString(_node: RString<OtherInfo & ParentInformation>): void;
+    /**
+     * {@link RSymbol}
+     */
+    protected visitRSymbol(_node: RSymbol<OtherInfo & ParentInformation>): void;
+}

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

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyntaxAwareCfgGuidedVisitor = void 0;
+const basic_cfg_guided_visitor_1 = require("./basic-cfg-guided-visitor");
+const type_1 = require("../r-bridge/lang-4.x/ast/model/type");
+const assert_1 = require("../util/assert");
+/**
+ * This visitor extends on the {@link BasicCfgGuidedVisitor} by dispatching visitors based on the AST type of the node.
+ *
+ * Use {@link BasicCfgGuidedVisitor#start} to start the traversal.
+ */
+class SyntaxAwareCfgGuidedVisitor extends basic_cfg_guided_visitor_1.BasicCfgGuidedVisitor {
+    /**
+     * Get the normalized AST node for the given id or fail if it does not exist.
+     */
+    getNormalizedAst(id) {
+        return this.config.normalizedAst.idMap.get(id);
+    }
+    onStatementNode(node) {
+        super.onStatementNode(node);
+        this.onExprOrStmtNode(node);
+    }
+    onExpressionNode(node) {
+        super.onExpressionNode(node);
+        this.onExprOrStmtNode(node);
+    }
+    onExprOrStmtNode(node) {
+        const astVertex = this.getNormalizedAst(node.id);
+        if (!astVertex) {
+            return;
+        }
+        const type = astVertex.type;
+        switch (type) {
+            case type_1.RType.Access:
+                return this.visitRAccess(astVertex);
+            case type_1.RType.Argument:
+                return this.visitRArgument(astVertex);
+            case type_1.RType.BinaryOp:
+                return this.visitRBinaryOp(astVertex);
+            case type_1.RType.ExpressionList:
+                return this.visitRExpressionList(astVertex);
+            case type_1.RType.ForLoop:
+                return this.visitRForLoop(astVertex);
+            case type_1.RType.FunctionCall:
+                return this.visitRFunctionCall(astVertex);
+            case type_1.RType.FunctionDefinition:
+                return this.visitRFunctionDefinition(astVertex);
+            case type_1.RType.IfThenElse:
+                return this.visitRIfThenElse(astVertex);
+            case type_1.RType.Parameter:
+                return this.visitRParameter(astVertex);
+            case type_1.RType.Pipe:
+                return this.visitRPipe(astVertex);
+            case type_1.RType.RepeatLoop:
+                return this.visitRRepeatLoop(astVertex);
+            case type_1.RType.UnaryOp:
+                return this.visitRUnaryOp(astVertex);
+            case type_1.RType.WhileLoop:
+                return this.visitRWhileLoop(astVertex);
+            case type_1.RType.Break:
+                return this.visitRBreak(astVertex);
+            case type_1.RType.Comment:
+                return this.visitRComment(astVertex);
+            case type_1.RType.LineDirective:
+                return this.visitRLineDirective(astVertex);
+            case type_1.RType.Logical:
+                return this.visitRLogical(astVertex);
+            case type_1.RType.Next:
+                return this.visitRNext(astVertex);
+            case type_1.RType.Number:
+                return this.visitRNumber(astVertex);
+            case type_1.RType.String:
+                return this.visitRString(astVertex);
+            case type_1.RType.Symbol:
+                return this.visitRSymbol(astVertex);
+            default:
+                (0, assert_1.assertUnreachable)(type);
+        }
+    }
+    /**
+     * {@link RAccess}
+     */
+    visitRAccess(_node) { }
+    /**
+     * {@link RArgument}
+     */
+    visitRArgument(_node) { }
+    /**
+     * {@link RBinaryOp}
+     */
+    visitRBinaryOp(_node) { }
+    /**
+     * {@link RExpressionList}
+     */
+    visitRExpressionList(_node) { }
+    /**
+     * {@link RForLoop}
+     */
+    visitRForLoop(_node) { }
+    /**
+     * {@link RFunctionCall}
+     */
+    visitRFunctionCall(_node) { }
+    /**
+     * {@link RFunctionDefinition}
+     */
+    visitRFunctionDefinition(_node) { }
+    /**
+     * {@link RIfThenElse}
+     */
+    visitRIfThenElse(_node) { }
+    /**
+     * {@link RParameter}
+     */
+    visitRParameter(_node) { }
+    /**
+     * {@link RPipe}
+     */
+    visitRPipe(_node) { }
+    /**
+     * {@link RRepeatLoop}
+     */
+    visitRRepeatLoop(_node) { }
+    /**
+     * {@link RUnaryOp}
+     */
+    visitRUnaryOp(_node) { }
+    /**
+     * {@link RWhileLoop}
+     */
+    visitRWhileLoop(_node) { }
+    /**
+     * {@link RBreak}
+     */
+    visitRBreak(_node) { }
+    /**
+     * {@link RComment}
+     */
+    visitRComment(_node) { }
+    /**
+     * {@link RLineDirective}
+     */
+    visitRLineDirective(_node) { }
+    /**
+     * {@link RLogical}
+     */
+    visitRLogical(_node) { }
+    /**
+     * {@link RNext}
+     */
+    visitRNext(_node) { }
+    /**
+     * {@link RNumber}
+     */
+    visitRNumber(_node) { }
+    /**
+     * {@link RString}
+     */
+    visitRString(_node) { }
+    /**
+     * {@link RSymbol}
+     */
+    visitRSymbol(_node) { }
+}
+exports.SyntaxAwareCfgGuidedVisitor = SyntaxAwareCfgGuidedVisitor;
+//# sourceMappingURL=syntax-cfg-guided-visitor.js.map

package/core/print/print.d.ts

@@ -1,5 +1,5 @@
 import type { IPipelineStep, StepProcessingFunction } from '../steps/pipeline-step';
-import type { TailOfArray } from '../../util/arrays';
+import type { TailOfArray } from '../../util/collections/arrays';
 /**
  * Defines the output format of a step that you are interested in.
  */

package/core/print/slice-diff-ansi.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.sliceDiffAnsi = sliceDiffAnsi;
 const range_1 = require("../../util/range");
 const assert_1 = require("../../util/assert");
-const ansi_1 = require("../../util/ansi");
+const ansi_1 = require("../../util/text/ansi");
 function grayOut() {
     return ansi_1.ansiFormatter.getFormatString({ color: 7 /* Colors.White */, effect: ansi_1.ColorEffect.Foreground, style: 2 /* FontStyles.Faint */ });
 }

package/core/steps/pipeline/create-pipeline.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyAndBuildPipeline = verifyAndBuildPipeline;
 const invalid_pipeline_error_1 = require("./invalid-pipeline-error");
 const json_1 = require("../../../util/json");
-const arrays_1 = require("../../../util/arrays");
+const arrays_1 = require("../../../util/collections/arrays");
 /**
  * Given a set of {@link IPipelineStep|steps} with their dependencies, this function verifies all requirements of {@link createPipeline}.
  */

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

@@ -26,7 +26,7 @@ export interface BuiltInConstantDefinition<Value> extends BaseBuiltInDefinition
 export interface BuiltInFunctionDefinition<BuiltInProcessor extends BuiltInMappingName> extends BaseBuiltInDefinition {
     readonly type: 'function';
     readonly processor: BuiltInProcessor;
-    readonly config: ConfigOfBuiltInMappingName<BuiltInProcessor>;
+    readonly config?: ConfigOfBuiltInMappingName<BuiltInProcessor>;
 }
 /**
  * Define a built-in replacement (like `[` or `$`) and the processor to use.
@@ -35,6 +35,9 @@ export interface BuiltInFunctionDefinition<BuiltInProcessor extends BuiltInMappi
 export interface BuiltInReplacementDefinition extends BaseBuiltInDefinition {
     readonly type: 'replacement';
     readonly suffixes: readonly ('<<-' | '<-')[];
+    readonly config: {
+        readIndices: boolean;
+    };
 }
 export type BuiltInDefinition = BuiltInConstantDefinition<any> | BuiltInFunctionDefinition<any> | BuiltInReplacementDefinition;
 /**
@@ -42,6 +45,6 @@ export type BuiltInDefinition = BuiltInConstantDefinition<any> | BuiltInFunction
  */
 export type BuiltInDefinitions = readonly BuiltInDefinition[];
 export declare function registerBuiltInFunctions<BuiltInProcessor extends BuiltInMappingName>({ names, processor, config, assumePrimitive }: BuiltInFunctionDefinition<BuiltInProcessor>): void;
-export declare function registerReplacementFunctions({ names, suffixes, assumePrimitive }: BuiltInReplacementDefinition): void;
+export declare function registerReplacementFunctions({ names, suffixes, assumePrimitive, config }: BuiltInReplacementDefinition): void;
 export declare function registerBuiltInDefinition(definition: BuiltInDefinition): void;
 export declare function registerBuiltInDefinitions(definitions: BuiltInDefinitions): void;

package/dataflow/environments/built-in-config.js

@@ -9,13 +9,14 @@ const identifier_1 = require("./identifier");
 const assert_1 = require("../../util/assert");
 function registerBuiltInConstant({ names, value, assumePrimitive }) {
     for (const name of names) {
+        const id = (0, built_in_1.builtInId)(name);
         const d = [{
                 type: identifier_1.ReferenceType.BuiltInConstant,
-                definedAt: built_in_1.BuiltIn,
+                definedAt: id,
                 controlDependencies: undefined,
                 value,
                 name,
-                nodeId: built_in_1.BuiltIn
+                nodeId: id
             }];
         built_in_1.BuiltInMemory.set(name, d);
         if (assumePrimitive) {
@@ -28,14 +29,16 @@ function registerBuiltInFunctions({ names, processor, config, assumePrimitive })
     (0, assert_1.guard)(mappedProcessor !== undefined, () => `Processor for ${processor} is undefined! Please pass a valid builtin name ${JSON.stringify(Object.keys(built_in_1.BuiltInProcessorMapper))}!`);
     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 = (0, built_in_1.builtInId)(name);
         const d = [{
                 type: identifier_1.ReferenceType.BuiltInFunction,
-                definedAt: built_in_1.BuiltIn,
+                definedAt: id,
                 controlDependencies: undefined,
                 /* eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-argument */
                 processor: (name, args, rootId, data) => mappedProcessor(name, args, rootId, data, config),
+                config,
                 name,
-                nodeId: built_in_1.BuiltIn
+                nodeId: id
             }];
         built_in_1.BuiltInMemory.set(name, d);
         if (assumePrimitive) {
@@ -44,19 +47,25 @@ function registerBuiltInFunctions({ names, processor, config, assumePrimitive })
     }
 }
 /* registers all combinations of replacements */
-function registerReplacementFunctions({ names, suffixes, assumePrimitive }) {
+function registerReplacementFunctions({ names, suffixes, assumePrimitive, config }) {
     const replacer = built_in_1.BuiltInProcessorMapper['builtin:replacement'];
     (0, assert_1.guard)(replacer !== undefined, () => 'Processor for builtin:replacement is undefined!');
     for (const assignment of names) {
         for (const suffix of suffixes) {
             const effectiveName = `${assignment}${suffix}`;
+            const id = (0, built_in_1.builtInId)(effectiveName);
             const d = [{
                     type: identifier_1.ReferenceType.BuiltInFunction,
-                    definedAt: built_in_1.BuiltIn,
-                    processor: (name, args, rootId, data) => replacer(name, args, rootId, data, { makeMaybe: true, assignmentOperator: suffix }),
+                    definedAt: id,
+                    processor: (name, args, rootId, data) => replacer(name, args, rootId, data, { makeMaybe: true, assignmentOperator: suffix, readIndices: config.readIndices }),
+                    config: {
+                        ...config,
+                        assignmentOperator: suffix,
+                        makeMaybe: true
+                    },
                     name: effectiveName,
                     controlDependencies: undefined,
-                    nodeId: built_in_1.BuiltIn
+                    nodeId: id
                 }];
             built_in_1.BuiltInMemory.set(effectiveName, d);
             if (assumePrimitive) {

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

@@ -1,5 +1,5 @@
 import type { DataflowProcessorInformation } from '../processor';
-import type { ExitPointType, DataflowInformation } from '../info';
+import type { DataflowInformation, ExitPointType } from '../info';
 import { processAccess } from '../internal/process/functions/call/built-in/built-in-access';
 import { processIfThenElse } from '../internal/process/functions/call/built-in/built-in-if-then-else';
 import { processAssignment } from '../internal/process/functions/call/built-in/built-in-assignment';
@@ -25,17 +25,23 @@ import type { ForceArguments } from '../internal/process/functions/call/common';
 import { processApply } from '../internal/process/functions/call/built-in/built-in-apply';
 import type { LinkTo } from '../../queries/catalog/call-context-query/call-context-query-format';
 import { processList } from '../internal/process/functions/call/built-in/built-in-list';
-export declare const BuiltIn = "built-in";
+import { processVector } from '../internal/process/functions/call/built-in/built-in-vector';
+import { processRm } from '../internal/process/functions/call/built-in/built-in-rm';
+import { processEvalCall } from '../internal/process/functions/call/built-in/built-in-eval';
+export type BuiltIn = `built-in:${string}`;
+export declare function builtInId(name: string): BuiltIn;
+export declare function isBuiltIn(name: NodeId | string): name is BuiltIn;
 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;
 export interface BuiltInIdentifierDefinition extends IdentifierReference {
     type: ReferenceType.BuiltInFunction;
-    definedAt: typeof BuiltIn;
+    definedAt: BuiltIn;
     processor: BuiltInIdentifierProcessor;
+    config?: object;
 }
 export interface BuiltInIdentifierConstant<T = unknown> extends IdentifierReference {
     type: ReferenceType.BuiltInConstant;
-    definedAt: typeof BuiltIn;
+    definedAt: BuiltIn;
     value: T;
 }
 export interface DefaultBuiltInProcessorConfiguration extends ForceArguments {
@@ -43,17 +49,21 @@ export interface DefaultBuiltInProcessorConfiguration extends ForceArguments {
     readonly cfg?: ExitPointType;
     readonly readAllArguments?: boolean;
     readonly hasUnknownSideEffects?: boolean | LinkTo<RegExp | string>;
+    /** record mapping the actual function name called to the arguments that should be treated as function calls */
+    readonly treatAsFnCall?: Record<string, readonly string[]>;
 }
 declare function defaultBuiltInProcessor<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: DefaultBuiltInProcessorConfiguration): DataflowInformation;
-export declare function registerBuiltInFunctions<Config, Proc extends BuiltInIdentifierProcessorWithConfig<Config>>(both: boolean, names: readonly Identifier[], processor: Proc, config: Config): void;
+export declare function registerBuiltInFunctions<Config extends object, Proc extends BuiltInIdentifierProcessorWithConfig<Config>>(both: boolean, names: readonly Identifier[], processor: Proc, config: Config): void;
 export declare const BuiltInProcessorMapper: {
     readonly 'builtin:default': typeof defaultBuiltInProcessor;
+    readonly 'builtin:eval': typeof processEvalCall;
     readonly 'builtin:apply': typeof processApply;
     readonly 'builtin:expression-list': typeof processExpressionList;
     readonly 'builtin:source': typeof processSourceCall;
     readonly 'builtin:access': typeof processAccess;
     readonly 'builtin:if-then-else': typeof processIfThenElse;
     readonly 'builtin:get': typeof processGet;
+    readonly 'builtin:rm': typeof processRm;
     readonly 'builtin:library': typeof processLibrary;
     readonly 'builtin:assignment': typeof processAssignment;
     readonly 'builtin:special-bin-op': typeof processSpecialBinOp;
@@ -65,6 +75,7 @@ export declare const BuiltInProcessorMapper: {
     readonly 'builtin:while-loop': typeof processWhileLoop;
     readonly 'builtin:replacement': typeof processReplacementFunction;
     readonly 'builtin:list': typeof processList;
+    readonly 'builtin:vector': typeof processVector;
 };
 export type BuiltInMappingName = keyof typeof BuiltInProcessorMapper;
 export type ConfigOfBuiltInMappingName<N extends BuiltInMappingName> = Parameters<typeof BuiltInProcessorMapper[N]>[4];

package/dataflow/environments/built-in.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EmptyBuiltInMemory = exports.BuiltInMemory = exports.BuiltInProcessorMapper = exports.BuiltIn = void 0;
+exports.EmptyBuiltInMemory = exports.BuiltInMemory = 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");
@@ -18,6 +20,7 @@ const built_in_quote_1 = require("../internal/process/functions/call/built-in/bu
 const built_in_function_definition_1 = require("../internal/process/functions/call/built-in/built-in-function-definition");
 const built_in_expression_list_1 = require("../internal/process/functions/call/built-in/built-in-expression-list");
 const built_in_get_1 = require("../internal/process/functions/call/built-in/built-in-get");
+const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const edge_1 = require("../graph/edge");
 const built_in_library_1 = require("../internal/process/functions/call/built-in/built-in-library");
 const built_in_source_1 = require("../internal/process/functions/call/built-in/built-in-source");
@@ -25,9 +28,19 @@ const built_in_apply_1 = require("../internal/process/functions/call/built-in/bu
 const built_in_config_1 = require("./built-in-config");
 const default_builtin_config_1 = require("./default-builtin-config");
 const built_in_list_1 = require("../internal/process/functions/call/built-in/built-in-list");
-exports.BuiltIn = 'built-in';
+const built_in_vector_1 = require("../internal/process/functions/call/built-in/built-in-vector");
+const built_in_rm_1 = require("../internal/process/functions/call/built-in/built-in-rm");
+const built_in_eval_1 = require("../internal/process/functions/call/built-in/built-in-eval");
+const vertex_1 = require("../graph/vertex");
+const type_1 = require("../../r-bridge/lang-4.x/ast/model/type");
+function builtInId(name) {
+    return `built-in:${name}`;
+}
+function isBuiltIn(name) {
+    return String(name).startsWith('built-in:');
+}
 function defaultBuiltInProcessor(name, args, rootId, data, config) {
-    const { information: res, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs });
+    const { information: res, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs, origin: 'builtin:default' });
     if (config.returnsNthArgument !== undefined) {
         const arg = config.returnsNthArgument === 'last' ? processedArguments[args.length - 1] : processedArguments[config.returnsNthArgument];
         if (arg !== undefined) {
@@ -49,6 +62,37 @@ function defaultBuiltInProcessor(name, args, rootId, data, config) {
             res.graph.markIdForUnknownSideEffects(rootId);
         }
     }
+    const fnCallNames = config.treatAsFnCall?.[name.content];
+    if (fnCallNames) {
+        for (const arg of args) {
+            if (arg !== r_function_call_1.EmptyArgument && arg.value && fnCallNames.includes(arg.name?.content)) {
+                const rhs = arg.value;
+                let fnName;
+                let fnId;
+                if (rhs.type === type_1.RType.String) {
+                    fnName = rhs.content.str;
+                    fnId = rhs.info.id;
+                }
+                else if (rhs.type === type_1.RType.Symbol) {
+                    fnName = rhs.content;
+                    fnId = rhs.info.id;
+                }
+                else {
+                    continue;
+                }
+                res.graph.updateToFunctionCall({
+                    tag: vertex_1.VertexType.FunctionCall,
+                    id: fnId,
+                    name: fnName,
+                    args: [],
+                    environment: data.environment,
+                    onlyBuiltin: false,
+                    cds: data.controlDependencies,
+                    origin: ['builtin:default']
+                });
+            }
+        }
+    }
     if (config.cfg !== undefined) {
         res.exitPoints = [...res.exitPoints, { type: config.cfg, nodeId: rootId, controlDependencies: data.controlDependencies }];
     }
@@ -57,13 +101,15 @@ function defaultBuiltInProcessor(name, args, rootId, data, config) {
 function registerBuiltInFunctions(both, names, processor, config) {
     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: exports.BuiltIn,
+                definedAt: id,
                 controlDependencies: undefined,
                 processor: (name, args, rootId, data) => processor(name, args, rootId, data, config),
+                config,
                 name,
-                nodeId: exports.BuiltIn
+                nodeId: id
             }];
         exports.BuiltInMemory.set(name, d);
         if (both) {
@@ -73,12 +119,14 @@ function registerBuiltInFunctions(both, names, processor, config) {
 }
 exports.BuiltInProcessorMapper = {
     'builtin:default': defaultBuiltInProcessor,
+    'builtin:eval': built_in_eval_1.processEvalCall,
     'builtin:apply': built_in_apply_1.processApply,
     'builtin:expression-list': built_in_expression_list_1.processExpressionList,
     'builtin:source': built_in_source_1.processSourceCall,
     'builtin:access': built_in_access_1.processAccess,
     'builtin:if-then-else': built_in_if_then_else_1.processIfThenElse,
     'builtin:get': built_in_get_1.processGet,
+    'builtin:rm': built_in_rm_1.processRm,
     'builtin:library': built_in_library_1.processLibrary,
     'builtin:assignment': built_in_assignment_1.processAssignment,
     'builtin:special-bin-op': built_in_special_bin_op_1.processSpecialBinOp,
@@ -89,7 +137,8 @@ exports.BuiltInProcessorMapper = {
     'builtin:repeat-loop': built_in_repeat_loop_1.processRepeatLoop,
     'builtin:while-loop': built_in_while_loop_1.processWhileLoop,
     'builtin:replacement': built_in_replacement_1.processReplacementFunction,
-    'builtin:list': built_in_list_1.processList
+    'builtin:list': built_in_list_1.processList,
+    'builtin:vector': built_in_vector_1.processVector,
 };
 exports.BuiltInMemory = new Map();
 exports.EmptyBuiltInMemory = new Map();

package/dataflow/environments/clone.d.ts

@@ -1,2 +1,7 @@
 import type { REnvironmentInformation } from './environment';
+/**
+ * Produce a clone of the given environment information.
+ * @param environment    - The environment information to clone.
+ * @param recurseParents - Whether to clone the parent environments as well.
+ */
 export declare function cloneEnvironmentInformation(environment: REnvironmentInformation, recurseParents?: boolean): REnvironmentInformation;

package/dataflow/environments/clone.js

@@ -14,6 +14,11 @@ function cloneEnvironment(environment, recurseParents) {
     clone.memory = new Map(JSON.parse(JSON.stringify([...environment.memory])));
     return clone;
 }
+/**
+ * Produce a clone of the given environment information.
+ * @param environment    - The environment information to clone.
+ * @param recurseParents - Whether to clone the parent environments as well.
+ */
 function cloneEnvironmentInformation(environment, recurseParents = true) {
     return {
         current: cloneEnvironment(environment.current, recurseParents),

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

@@ -1,5 +1,7 @@
 import type { BuiltInDefinitions } from './built-in-config';
+import type { BuiltInMappingName } from './built-in';
 /**
  * Contains the built-in definitions recognized by flowR
  */
 export declare const DefaultBuiltinConfig: BuiltInDefinitions;
+export declare function getDefaultProcessor(name: string): BuiltInMappingName | 'unnamed' | undefined;