@eagleoutice/flowr 2.3.0 → 2.4.1

package/core/steps/pipeline/default-pipelines.d.ts

@@ -8,6 +8,20 @@ import type { RShell } from '../../../r-bridge/shell';
 import type { TreeSitterExecutor } from '../../../r-bridge/lang-4.x/tree-sitter/tree-sitter-executor';
 import type { FlowrConfigOptions } from '../../../config';
 export declare const DEFAULT_SLICING_PIPELINE: import("./pipeline").Pipeline<{
+    readonly name: "slice";
+    readonly humanReadableName: "static slice";
+    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
+    readonly processor: (results: {
+        dataflow?: import("../../../dataflow/info").DataflowInformation;
+        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>, _config: FlowrConfigOptions) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+    };
+    readonly dependencies: readonly ["dataflow"];
+    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
+} | {
     readonly name: "parse";
     readonly humanReadableName: "parse with R shell";
     readonly description: "Parse the given R code into an AST";
@@ -60,20 +74,6 @@ export declare const DEFAULT_SLICING_PIPELINE: import("./pipeline").Pipeline<{
         readonly 4: typeof import("../../print/dataflow-printer").dataflowGraphToMermaidUrl;
     };
     readonly dependencies: readonly ["normalize"];
-} | {
-    readonly name: "slice";
-    readonly humanReadableName: "static slice";
-    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
-    readonly processor: (results: {
-        dataflow?: import("../../../dataflow/info").DataflowInformation;
-        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
-    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>, config: FlowrConfigOptions) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
-    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
-    readonly printer: {
-        readonly 0: typeof import("../../print/print").internalPrinter;
-    };
-    readonly dependencies: readonly ["dataflow"];
-    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
 } | {
     readonly name: "reconstruct";
     readonly humanReadableName: "static code reconstruction";
@@ -90,6 +90,20 @@ export declare const DEFAULT_SLICING_PIPELINE: import("./pipeline").Pipeline<{
     readonly requiredInput: import("../all/static-slicing/10-reconstruct").ReconstructRequiredInput;
 }>;
 export declare const DEFAULT_SLICE_AND_RECONSTRUCT_PIPELINE: import("./pipeline").Pipeline<{
+    readonly name: "slice";
+    readonly humanReadableName: "static slice";
+    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
+    readonly processor: (results: {
+        dataflow?: import("../../../dataflow/info").DataflowInformation;
+        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>, _config: FlowrConfigOptions) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+    };
+    readonly dependencies: readonly ["dataflow"];
+    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
+} | {
     readonly name: "parse";
     readonly humanReadableName: "parse with R shell";
     readonly description: "Parse the given R code into an AST";
@@ -142,20 +156,6 @@ export declare const DEFAULT_SLICE_AND_RECONSTRUCT_PIPELINE: import("./pipeline"
         readonly 4: typeof import("../../print/dataflow-printer").dataflowGraphToMermaidUrl;
     };
     readonly dependencies: readonly ["normalize"];
-} | {
-    readonly name: "slice";
-    readonly humanReadableName: "static slice";
-    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
-    readonly processor: (results: {
-        dataflow?: import("../../../dataflow/info").DataflowInformation;
-        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
-    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>, config: FlowrConfigOptions) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
-    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
-    readonly printer: {
-        readonly 0: typeof import("../../print/print").internalPrinter;
-    };
-    readonly dependencies: readonly ["dataflow"];
-    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
 } | {
     readonly name: "reconstruct";
     readonly humanReadableName: "static code reconstruction";
@@ -172,6 +172,20 @@ export declare const DEFAULT_SLICE_AND_RECONSTRUCT_PIPELINE: import("./pipeline"
     readonly requiredInput: import("../all/static-slicing/10-reconstruct").ReconstructRequiredInput;
 }>;
 export declare const DEFAULT_SLICE_WITHOUT_RECONSTRUCT_PIPELINE: import("./pipeline").Pipeline<{
+    readonly name: "slice";
+    readonly humanReadableName: "static slice";
+    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
+    readonly processor: (results: {
+        dataflow?: import("../../../dataflow/info").DataflowInformation;
+        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>, _config: FlowrConfigOptions) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+    };
+    readonly dependencies: readonly ["dataflow"];
+    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
+} | {
     readonly name: "parse";
     readonly humanReadableName: "parse with R shell";
     readonly description: "Parse the given R code into an AST";
@@ -224,22 +238,22 @@ export declare const DEFAULT_SLICE_WITHOUT_RECONSTRUCT_PIPELINE: import("./pipel
         readonly 4: typeof import("../../print/dataflow-printer").dataflowGraphToMermaidUrl;
     };
     readonly dependencies: readonly ["normalize"];
-} | {
+}>;
+export declare const TREE_SITTER_SLICING_PIPELINE: import("./pipeline").Pipeline<{
     readonly name: "slice";
     readonly humanReadableName: "static slice";
     readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
     readonly processor: (results: {
         dataflow?: import("../../../dataflow/info").DataflowInformation;
         normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
-    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>, config: FlowrConfigOptions) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
+    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>, _config: FlowrConfigOptions) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
     readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
     readonly printer: {
         readonly 0: typeof import("../../print/print").internalPrinter;
     };
     readonly dependencies: readonly ["dataflow"];
     readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
-}>;
-export declare const TREE_SITTER_SLICING_PIPELINE: import("./pipeline").Pipeline<{
+} | {
     readonly humanReadableName: "dataflow";
     readonly processor: (results: {
         normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
@@ -259,20 +273,6 @@ export declare const TREE_SITTER_SLICING_PIPELINE: import("./pipeline").Pipeline
         readonly 4: typeof import("../../print/dataflow-printer").dataflowGraphToMermaidUrl;
     };
     readonly dependencies: readonly ["normalize"];
-} | {
-    readonly name: "slice";
-    readonly humanReadableName: "static slice";
-    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
-    readonly processor: (results: {
-        dataflow?: import("../../../dataflow/info").DataflowInformation;
-        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
-    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>, config: FlowrConfigOptions) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
-    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
-    readonly printer: {
-        readonly 0: typeof import("../../print/print").internalPrinter;
-    };
-    readonly dependencies: readonly ["dataflow"];
-    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
 } | {
     readonly name: "reconstruct";
     readonly humanReadableName: "static code reconstruction";
@@ -321,6 +321,20 @@ export declare const TREE_SITTER_SLICING_PIPELINE: import("./pipeline").Pipeline
     readonly requiredInput: import("../all/core/10-normalize").NormalizeRequiredInput;
 }>;
 export declare const TREE_SITTER_SLICE_AND_RECONSTRUCT_PIPELINE: import("./pipeline").Pipeline<{
+    readonly name: "slice";
+    readonly humanReadableName: "static slice";
+    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
+    readonly processor: (results: {
+        dataflow?: import("../../../dataflow/info").DataflowInformation;
+        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>, _config: FlowrConfigOptions) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+    };
+    readonly dependencies: readonly ["dataflow"];
+    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
+} | {
     readonly humanReadableName: "dataflow";
     readonly processor: (results: {
         normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
@@ -340,20 +354,6 @@ export declare const TREE_SITTER_SLICE_AND_RECONSTRUCT_PIPELINE: import("./pipel
         readonly 4: typeof import("../../print/dataflow-printer").dataflowGraphToMermaidUrl;
     };
     readonly dependencies: readonly ["normalize"];
-} | {
-    readonly name: "slice";
-    readonly humanReadableName: "static slice";
-    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
-    readonly processor: (results: {
-        dataflow?: import("../../../dataflow/info").DataflowInformation;
-        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
-    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>, config: FlowrConfigOptions) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
-    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
-    readonly printer: {
-        readonly 0: typeof import("../../print/print").internalPrinter;
-    };
-    readonly dependencies: readonly ["dataflow"];
-    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
 } | {
     readonly name: "reconstruct";
     readonly humanReadableName: "static code reconstruction";
@@ -402,6 +402,20 @@ export declare const TREE_SITTER_SLICE_AND_RECONSTRUCT_PIPELINE: import("./pipel
     readonly requiredInput: import("../all/core/10-normalize").NormalizeRequiredInput;
 }>;
 export declare const TREE_SITTER_SLICE_WITHOUT_RECONSTRUCT_PIPELINE: import("./pipeline").Pipeline<{
+    readonly name: "slice";
+    readonly humanReadableName: "static slice";
+    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
+    readonly processor: (results: {
+        dataflow?: import("../../../dataflow/info").DataflowInformation;
+        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>, _config: FlowrConfigOptions) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+    };
+    readonly dependencies: readonly ["dataflow"];
+    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
+} | {
     readonly humanReadableName: "dataflow";
     readonly processor: (results: {
         normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
@@ -421,20 +435,6 @@ export declare const TREE_SITTER_SLICE_WITHOUT_RECONSTRUCT_PIPELINE: import("./p
         readonly 4: typeof import("../../print/dataflow-printer").dataflowGraphToMermaidUrl;
     };
     readonly dependencies: readonly ["normalize"];
-} | {
-    readonly name: "slice";
-    readonly humanReadableName: "static slice";
-    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
-    readonly processor: (results: {
-        dataflow?: import("../../../dataflow/info").DataflowInformation;
-        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
-    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>, config: FlowrConfigOptions) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
-    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
-    readonly printer: {
-        readonly 0: typeof import("../../print/print").internalPrinter;
-    };
-    readonly dependencies: readonly ["dataflow"];
-    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
 } | {
     readonly name: "parse";
     readonly humanReadableName: "parse with tree-sitter";

package/dataflow/environments/append.js

@@ -25,7 +25,7 @@ function appendIEnvironmentWith(base, next) {
             map.set(key, value);
         }
     }
-    const parent = base.parent === environment_1.BuiltInEnvironment ? environment_1.BuiltInEnvironment : appendIEnvironmentWith(base.parent, next.parent);
+    const parent = base.parent.builtInEnv ? base.parent : appendIEnvironmentWith(base.parent, next.parent);
     const out = new environment_1.Environment(parent);
     out.memory = map;
     return out;

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

@@ -1,4 +1,5 @@
 import type { BuiltInMappingName, ConfigOfBuiltInMappingName } from './built-in';
+import { BuiltIns } from './built-in';
 import type { Identifier } from './identifier';
 export interface BaseBuiltInDefinition {
     /** The type of the built-in configuration */
@@ -45,7 +46,14 @@ export type BuiltInDefinition = BuiltInConstantDefinition<any> | BuiltInFunction
  * @see DefaultBuiltinConfig
  */
 export type BuiltInDefinitions = BuiltInDefinition[];
-export declare function registerBuiltInFunctions<BuiltInProcessor extends BuiltInMappingName>({ names, processor, config, assumePrimitive }: BuiltInFunctionDefinition<BuiltInProcessor>): 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;
+/**
+ * Get the {@link BuiltIns#builtInMemory} and {@link BuiltIns#emptyBuiltInMemory} for the {@link DefaultBuiltinConfig}.
+ */
+export declare function getDefaultBuiltInDefinitions(): BuiltIns;
+/**
+ * Get the {@link BuiltIns#builtInMemory} and {@link BuiltIns#emptyBuiltInMemory} for the given list of built-in definitions.
+ *
+ * @param definitions - the list of built-in definitions
+ * @param loadDefaults - whether to first add the {@link DefaultBuiltinConfig} before the given {@link definitions}
+ */
+export declare function getBuiltInDefinitions(definitions: BuiltInDefinitions, loadDefaults: boolean | undefined): BuiltIns;

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

@@ -1,92 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerBuiltInFunctions = registerBuiltInFunctions;
-exports.registerReplacementFunctions = registerReplacementFunctions;
-exports.registerBuiltInDefinition = registerBuiltInDefinition;
-exports.registerBuiltInDefinitions = registerBuiltInDefinitions;
+exports.getDefaultBuiltInDefinitions = getDefaultBuiltInDefinitions;
+exports.getBuiltInDefinitions = getBuiltInDefinitions;
 const built_in_1 = require("./built-in");
-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: id,
-                controlDependencies: undefined,
-                value,
-                name,
-                nodeId: id
-            }];
-        built_in_1.BuiltInMemory.set(name, d);
-        if (assumePrimitive) {
-            built_in_1.EmptyBuiltInMemory.set(name, d);
-        }
+const default_builtin_config_1 = require("./default-builtin-config");
+/**
+ * Get the {@link BuiltIns#builtInMemory} and {@link BuiltIns#emptyBuiltInMemory} for the {@link DefaultBuiltinConfig}.
+ */
+function getDefaultBuiltInDefinitions() {
+    const builtIns = new built_in_1.BuiltIns();
+    for (const definition of default_builtin_config_1.DefaultBuiltinConfig) {
+        builtIns.registerBuiltInDefinition(definition);
     }
+    return builtIns;
 }
-function registerBuiltInFunctions({ names, processor, config, assumePrimitive }) {
-    const mappedProcessor = built_in_1.BuiltInProcessorMapper[processor];
-    (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: 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: id
-            }];
-        built_in_1.BuiltInMemory.set(name, d);
-        if (assumePrimitive) {
-            built_in_1.EmptyBuiltInMemory.set(name, d);
-        }
+/**
+ * Get the {@link BuiltIns#builtInMemory} and {@link BuiltIns#emptyBuiltInMemory} for the given list of built-in definitions.
+ *
+ * @param definitions - the list of built-in definitions
+ * @param loadDefaults - whether to first add the {@link DefaultBuiltinConfig} before the given {@link definitions}
+ */
+function getBuiltInDefinitions(definitions, loadDefaults) {
+    let builtIns = new built_in_1.BuiltIns();
+    if (loadDefaults) {
+        builtIns = getDefaultBuiltInDefinitions();
     }
-}
-/* registers all combinations of replacements */
-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: 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: id
-                }];
-            built_in_1.BuiltInMemory.set(effectiveName, d);
-            if (assumePrimitive) {
-                built_in_1.EmptyBuiltInMemory.set(effectiveName, d);
-            }
-        }
-    }
-}
-function registerBuiltInDefinition(definition) {
-    switch (definition.type) {
-        case 'constant':
-            return registerBuiltInConstant(definition);
-        case 'function':
-            return registerBuiltInFunctions(definition);
-        case 'replacement':
-            return registerReplacementFunctions(definition);
-    }
-}
-function registerBuiltInDefinitions(definitions) {
     for (const definition of definitions) {
-        registerBuiltInDefinition(definition);
+        builtIns.registerBuiltInDefinition(definition);
     }
+    return builtIns;
 }
 //# sourceMappingURL=built-in-config.js.map

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

@@ -30,9 +30,10 @@ import { processRm } from '../internal/process/functions/call/built-in/built-in-
 import { processEvalCall } from '../internal/process/functions/call/built-in/built-in-eval';
 import type { REnvironmentInformation } from './environment';
 import type { Value } from '../eval/values/r-value';
-import { resolveAsVector, resolveAsSeq, resolveAsMinus, resolveAsPlus } from '../eval/resolve/resolve';
+import { resolveAsMinus, resolveAsPlus, resolveAsSeq, resolveAsVector } from '../eval/resolve/resolve';
 import type { DataflowGraph } from '../graph/graph';
 import type { VariableResolve } from '../../config';
+import type { BuiltInConstantDefinition, BuiltInDefinition, BuiltInFunctionDefinition, BuiltInReplacementDefinition } from './built-in-config';
 export type BuiltIn = `built-in:${string}`;
 export declare function builtInId(name: string): BuiltIn;
 export declare function isBuiltIn(name: NodeId | string): name is BuiltIn;
@@ -54,7 +55,7 @@ export interface DefaultBuiltInProcessorConfiguration extends ForceArguments {
     readonly returnsNthArgument?: number | 'last';
     readonly cfg?: ExitPointType;
     readonly readAllArguments?: boolean;
-    readonly hasUnknownSideEffects?: boolean | LinkTo<RegExp | string>;
+    readonly hasUnknownSideEffects?: boolean | LinkTo;
     /** record mapping the actual function name called to the arguments that should be treated as function calls */
     readonly treatAsFnCall?: Record<string, readonly string[]>;
     /** Name that should be used for the origin (useful when needing to differentiate between
@@ -63,8 +64,8 @@ export interface DefaultBuiltInProcessorConfiguration extends ForceArguments {
     readonly useAsProcessor?: UseAsProcessors;
 }
 export type BuiltInEvalHandler = (resolve: VariableResolve, a: RNodeWithParent, env?: REnvironmentInformation, graph?: DataflowGraph, map?: AstIdMap) => Value;
-declare function defaultBuiltInProcessor<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: DefaultBuiltInProcessorConfiguration): DataflowInformation;
-export declare function registerBuiltInFunctions<Config extends object, Proc extends BuiltInIdentifierProcessorWithConfig<Config>>(both: boolean, names: readonly Identifier[], processor: Proc, config: Config): void;
+declare function defaultBuiltInProcessor<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, { returnsNthArgument, useAsProcessor, forceArgs, readAllArguments, cfg, hasUnknownSideEffects, treatAsFnCall }: DefaultBuiltInProcessorConfiguration): DataflowInformation;
+export declare function registerBuiltInFunctions<Config extends object, Proc extends BuiltInIdentifierProcessorWithConfig<Config>>(both: boolean, names: readonly Identifier[], processor: Proc, config: Config, builtIns: BuiltIns): void;
 export declare const BuiltInProcessorMapper: {
     readonly 'builtin:default': typeof defaultBuiltInProcessor;
     readonly 'builtin:eval': typeof processEvalCall;
@@ -96,6 +97,39 @@ export declare const BuiltInEvalHandlerMapper: {
 };
 export type BuiltInMappingName = keyof typeof BuiltInProcessorMapper;
 export type ConfigOfBuiltInMappingName<N extends BuiltInMappingName> = Parameters<typeof BuiltInProcessorMapper[N]>[4];
-export declare const BuiltInMemory: Map<Identifier, IdentifierDefinition[]>;
-export declare const EmptyBuiltInMemory: Map<Identifier, IdentifierDefinition[]>;
+export type BuiltInMemory = Map<Identifier, IdentifierDefinition[]>;
+export declare class BuiltIns {
+    /**
+     * Register a built-in constant (like `NULL` or `TRUE`) to the given {@link builtIns}
+     */
+    registerBuiltInConstant<T>({ names, value, assumePrimitive }: BuiltInConstantDefinition<T>): void;
+    /**
+     * Register a built-in function (like `print` or `c`) to the given {@link builtIns}
+     */
+    registerBuiltInFunctions<BuiltInProcessor extends BuiltInMappingName>({ names, processor, config, assumePrimitive }: BuiltInFunctionDefinition<BuiltInProcessor>): void;
+    /**
+     * Registers all combinations of replacements
+     */
+    registerReplacementFunctions({ names, suffixes, assumePrimitive, config }: BuiltInReplacementDefinition): void;
+    /**
+     * Register a single {@link BuiltInDefinition} to the given memories in {@link builtIns}
+     */
+    registerBuiltInDefinition(definition: BuiltInDefinition): void;
+    /**
+     * The built-in {@link REnvironmentInformation|environment} is the root of all environments.
+     *
+     * For its default content (when not overwritten by a flowR config),
+     * see the {@link DefaultBuiltinConfig}.
+     */
+    builtInMemory: BuiltInMemory;
+    /**
+     * The twin of the {@link builtInMemory} but with less built ins defined for
+     * cases in which we want some commonly overwritten variables to remain open.
+     * If you do not know if you need the empty environment, you do not need the empty environment (right now).
+     *
+     * @see {@link builtInMemory}
+     */
+    emptyBuiltInMemory: BuiltInMemory;
+    set(identifier: Identifier, definition: IdentifierDefinition[], includeInEmptyMemory: boolean | undefined): void;
+}
 export {};