@eagleoutice/flowr 2.0.25 → 2.1.0

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

@@ -16,7 +16,7 @@ export declare const DEFAULT_SLICING_PIPELINE: import("./pipeline").Pipeline<{
     readonly humanReadableName: "normalize";
     readonly description: "Normalize the AST to flowR's AST";
     readonly processor: (results: {
-        parse?: string | undefined;
+        parse?: string;
     }, input: Partial<import("../all/core/10-normalize").NormalizeRequiredInput>) => import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
     readonly executed: import("../pipeline-step").PipelineStepStage.OncePerFile;
     readonly printer: {
@@ -31,9 +31,9 @@ export declare const DEFAULT_SLICING_PIPELINE: import("./pipeline").Pipeline<{
 } | {
     readonly humanReadableName: "dataflow";
     readonly processor: (results: {
-        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>> | undefined;
+        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
     }, input: {
-        request?: import("../../../r-bridge/retriever").RParseRequests | undefined;
+        request?: import("../../../r-bridge/retriever").RParseRequests;
     }) => import("../../../dataflow/info").DataflowInformation;
     readonly requiredInput: {};
     readonly name: "dataflow";
@@ -52,8 +52,8 @@ export declare const DEFAULT_SLICING_PIPELINE: import("./pipeline").Pipeline<{
     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 | undefined;
-        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>> | undefined;
+        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>) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
     readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
     readonly printer: {
@@ -66,8 +66,8 @@ export declare const DEFAULT_SLICING_PIPELINE: import("./pipeline").Pipeline<{
     readonly humanReadableName: "static code reconstruction";
     readonly description: "Reconstruct R code from the static slice";
     readonly processor: (results: {
-        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>> | undefined;
-        slice?: import("../../../slicing/static/slicer-types").SliceResult | undefined;
+        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+        slice?: import("../../../slicing/static/slicer-types").SliceResult;
     }, input: Partial<import("../all/static-slicing/10-reconstruct").ReconstructRequiredInput>) => import("../../../reconstruct/reconstruct").ReconstructionResult;
     readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
     readonly printer: {
@@ -94,7 +94,7 @@ export declare const DEFAULT_SLICE_AND_RECONSTRUCT_PIPELINE: import("./pipeline"
     readonly humanReadableName: "normalize";
     readonly description: "Normalize the AST to flowR's AST";
     readonly processor: (results: {
-        parse?: string | undefined;
+        parse?: string;
     }, input: Partial<import("../all/core/10-normalize").NormalizeRequiredInput>) => import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
     readonly executed: import("../pipeline-step").PipelineStepStage.OncePerFile;
     readonly printer: {
@@ -109,9 +109,9 @@ export declare const DEFAULT_SLICE_AND_RECONSTRUCT_PIPELINE: import("./pipeline"
 } | {
     readonly humanReadableName: "dataflow";
     readonly processor: (results: {
-        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>> | undefined;
+        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
     }, input: {
-        request?: import("../../../r-bridge/retriever").RParseRequests | undefined;
+        request?: import("../../../r-bridge/retriever").RParseRequests;
     }) => import("../../../dataflow/info").DataflowInformation;
     readonly requiredInput: {};
     readonly name: "dataflow";
@@ -130,8 +130,8 @@ export declare const DEFAULT_SLICE_AND_RECONSTRUCT_PIPELINE: import("./pipeline"
     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 | undefined;
-        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>> | undefined;
+        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>) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
     readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
     readonly printer: {
@@ -144,8 +144,8 @@ export declare const DEFAULT_SLICE_AND_RECONSTRUCT_PIPELINE: import("./pipeline"
     readonly humanReadableName: "static code reconstruction";
     readonly description: "Reconstruct R code from the static slice";
     readonly processor: (results: {
-        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>> | undefined;
-        slice?: import("../../../slicing/static/slicer-types").SliceResult | undefined;
+        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+        slice?: import("../../../slicing/static/slicer-types").SliceResult;
     }, input: Partial<import("../all/static-slicing/10-reconstruct").ReconstructRequiredInput>) => import("../../../reconstruct/reconstruct").ReconstructionResult;
     readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
     readonly printer: {
@@ -172,7 +172,7 @@ export declare const DEFAULT_DATAFLOW_PIPELINE: import("./pipeline").Pipeline<{
     readonly humanReadableName: "normalize";
     readonly description: "Normalize the AST to flowR's AST";
     readonly processor: (results: {
-        parse?: string | undefined;
+        parse?: string;
     }, input: Partial<import("../all/core/10-normalize").NormalizeRequiredInput>) => import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
     readonly executed: import("../pipeline-step").PipelineStepStage.OncePerFile;
     readonly printer: {
@@ -187,9 +187,9 @@ export declare const DEFAULT_DATAFLOW_PIPELINE: import("./pipeline").Pipeline<{
 } | {
     readonly humanReadableName: "dataflow";
     readonly processor: (results: {
-        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>> | undefined;
+        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
     }, input: {
-        request?: import("../../../r-bridge/retriever").RParseRequests | undefined;
+        request?: import("../../../r-bridge/retriever").RParseRequests;
     }) => import("../../../dataflow/info").DataflowInformation;
     readonly requiredInput: {};
     readonly name: "dataflow";
@@ -222,7 +222,7 @@ export declare const DEFAULT_NORMALIZE_PIPELINE: import("./pipeline").Pipeline<{
     readonly humanReadableName: "normalize";
     readonly description: "Normalize the AST to flowR's AST";
     readonly processor: (results: {
-        parse?: string | undefined;
+        parse?: string;
     }, input: Partial<import("../all/core/10-normalize").NormalizeRequiredInput>) => import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
     readonly executed: import("../pipeline-step").PipelineStepStage.OncePerFile;
     readonly printer: {

package/core/steps/pipeline/pipeline.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPipeline = void 0;
+exports.createPipeline = createPipeline;
 const create_pipeline_1 = require("./create-pipeline");
 /**
  * Creates a {@link Pipeline|pipeline} from a given collection of {@link IPipelineStep|steps}.
@@ -24,5 +24,4 @@ const create_pipeline_1 = require("./create-pipeline");
 function createPipeline(...steps) {
     return (0, create_pipeline_1.verifyAndBuildPipeline)(steps);
 }
-exports.createPipeline = createPipeline;
 //# sourceMappingURL=pipeline.js.map

package/dataflow/environments/append.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.appendEnvironment = void 0;
+exports.appendEnvironment = appendEnvironment;
 const assert_1 = require("../../util/assert");
 const environment_1 = require("./environment");
 function uniqueMergeValues(old, value) {
@@ -43,5 +43,4 @@ function appendEnvironment(base, next) {
         level: base.level,
     };
 }
-exports.appendEnvironment = appendEnvironment;
 //# sourceMappingURL=append.js.map

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

@@ -0,0 +1,47 @@
+import type { BuiltInMappingName, ConfigOfBuiltInMappingName } from './built-in';
+import type { Identifier } from './identifier';
+export interface BaseBuiltInDefinition {
+    /** The type of the built-in configuration */
+    readonly type: string;
+    /** The function name to define to the given configuration */
+    readonly names: readonly Identifier[];
+    /** Should we assume that the value is a primitive? */
+    readonly assumePrimitive?: boolean;
+}
+/**
+ * Define a built-in constant (like `NULL` or `TRUE`) and the TS value it should have
+ *
+ * @template Value - The type of the constant value
+ */
+export interface BuiltInConstantDefinition<Value> extends BaseBuiltInDefinition {
+    readonly type: 'constant';
+    /** The constant value to define */
+    readonly value: Value;
+}
+/**
+ * Define a built-in function (like `print` or `c`) and the processor to use.
+ *
+ * @template BuiltInProcessor - The processor to use for this function
+ */
+export interface BuiltInFunctionDefinition<BuiltInProcessor extends BuiltInMappingName> extends BaseBuiltInDefinition {
+    readonly type: 'function';
+    readonly processor: BuiltInProcessor;
+    readonly config: ConfigOfBuiltInMappingName<BuiltInProcessor>;
+}
+/**
+ * Define a built-in replacement (like `[` or `$`) and the processor to use.
+ * This is a convenience for manually combined function calls with `builtin:replacement`.
+ */
+export interface BuiltInReplacementDefinition extends BaseBuiltInDefinition {
+    readonly type: 'replacement';
+    readonly suffixes: readonly ('<<-' | '<-')[];
+}
+export type BuiltInDefinition = BuiltInConstantDefinition<any> | BuiltInFunctionDefinition<any> | BuiltInReplacementDefinition;
+/**
+ * @see DefaultBuiltinConfig
+ */
+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 registerBuiltInDefinition(definition: BuiltInDefinition): void;
+export declare function registerBuiltInDefinitions(definitions: BuiltInDefinitions): void;

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

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerBuiltInFunctions = registerBuiltInFunctions;
+exports.registerReplacementFunctions = registerReplacementFunctions;
+exports.registerBuiltInDefinition = registerBuiltInDefinition;
+exports.registerBuiltInDefinitions = registerBuiltInDefinitions;
+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 d = [{
+                type: identifier_1.ReferenceType.BuiltInConstant,
+                definedAt: built_in_1.BuiltIn,
+                controlDependencies: undefined,
+                value,
+                name,
+                nodeId: built_in_1.BuiltIn
+            }];
+        built_in_1.BuiltInMemory.set(name, d);
+        if (assumePrimitive) {
+            built_in_1.EmptyBuiltInMemory.set(name, d);
+        }
+    }
+}
+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 d = [{
+                type: identifier_1.ReferenceType.BuiltInFunction,
+                definedAt: built_in_1.BuiltIn,
+                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),
+                name,
+                nodeId: built_in_1.BuiltIn
+            }];
+        built_in_1.BuiltInMemory.set(name, d);
+        if (assumePrimitive) {
+            built_in_1.EmptyBuiltInMemory.set(name, d);
+        }
+    }
+}
+/* registers all combinations of replacements */
+function registerReplacementFunctions({ names, suffixes, assumePrimitive }) {
+    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 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 }),
+                    name: effectiveName,
+                    controlDependencies: undefined,
+                    nodeId: built_in_1.BuiltIn
+                }];
+            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);
+    }
+}
+//# sourceMappingURL=built-in-config.js.map

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

@@ -1,26 +1,69 @@
 import type { DataflowProcessorInformation } from '../processor';
-import type { DataflowInformation } from '../info';
+import type { ExitPointType, DataflowInformation } 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';
+import { processSpecialBinOp } from '../internal/process/functions/call/built-in/built-in-special-bin-op';
+import { processPipe } from '../internal/process/functions/call/built-in/built-in-pipe';
+import { processForLoop } from '../internal/process/functions/call/built-in/built-in-for-loop';
+import { processRepeatLoop } from '../internal/process/functions/call/built-in/built-in-repeat-loop';
+import { processWhileLoop } from '../internal/process/functions/call/built-in/built-in-while-loop';
 import type { Identifier, IdentifierDefinition, IdentifierReference } from './identifier';
+import { ReferenceType } from './identifier';
+import { processReplacementFunction } from '../internal/process/functions/call/built-in/built-in-replacement';
+import { processQuote } from '../internal/process/functions/call/built-in/built-in-quote';
+import { processFunctionDefinition } from '../internal/process/functions/call/built-in/built-in-function-definition';
+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 { ParentInformation } 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 { RSymbol } from '../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { processLibrary } from '../internal/process/functions/call/built-in/built-in-library';
+import { processSourceCall } from '../internal/process/functions/call/built-in/built-in-source';
+import type { ForceArguments } from '../internal/process/functions/call/common';
+import { processApply } from '../internal/process/functions/call/built-in/built-in-apply';
 export declare const BuiltIn = "built-in";
 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 {
-    kind: 'built-in-function';
+    type: ReferenceType.BuiltInFunction;
     definedAt: typeof BuiltIn;
     processor: BuiltInIdentifierProcessor;
 }
 export interface BuiltInIdentifierConstant<T = unknown> extends IdentifierReference {
-    kind: 'built-in-value';
+    type: ReferenceType.BuiltInConstant;
     definedAt: typeof BuiltIn;
     value: T;
 }
+declare function defaultBuiltInProcessor<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
+    returnsNthArgument?: number | 'last';
+    cfg?: ExitPointType;
+    readAllArguments?: boolean;
+    hasUnknownSideEffects?: boolean;
+} & ForceArguments): DataflowInformation;
 export declare function registerBuiltInFunctions<Config, Proc extends BuiltInIdentifierProcessorWithConfig<Config>>(both: boolean, names: readonly Identifier[], processor: Proc, config: Config): void;
-export declare function registerReplacementFunctions(standardConfig: {
-    makeMaybe?: boolean;
-}, assignments: readonly ('<-' | '<<-')[], ...prefixes: readonly Identifier[]): void;
+export declare const BuiltInProcessorMapper: {
+    readonly 'builtin:default': typeof defaultBuiltInProcessor;
+    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:library': typeof processLibrary;
+    readonly 'builtin:assignment': typeof processAssignment;
+    readonly 'builtin:special-bin-op': typeof processSpecialBinOp;
+    readonly 'builtin:pipe': typeof processPipe;
+    readonly 'builtin:function-definition': typeof processFunctionDefinition;
+    readonly 'builtin:quote': typeof processQuote;
+    readonly 'builtin:for-loop': typeof processForLoop;
+    readonly 'builtin:repeat-loop': typeof processRepeatLoop;
+    readonly 'builtin:while-loop': typeof processWhileLoop;
+    readonly 'builtin:replacement': typeof processReplacementFunction;
+};
+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 {};

package/dataflow/environments/built-in.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EmptyBuiltInMemory = exports.BuiltInMemory = exports.registerReplacementFunctions = exports.registerBuiltInFunctions = exports.BuiltIn = void 0;
+exports.EmptyBuiltInMemory = exports.BuiltInMemory = exports.BuiltInProcessorMapper = exports.BuiltIn = void 0;
+exports.registerBuiltInFunctions = registerBuiltInFunctions;
 const known_call_handling_1 = require("../internal/process/functions/call/known-call-handling");
 const built_in_access_1 = require("../internal/process/functions/call/built-in/built-in-access");
 const built_in_if_then_else_1 = require("../internal/process/functions/call/built-in/built-in-if-then-else");
@@ -10,28 +11,32 @@ const built_in_pipe_1 = require("../internal/process/functions/call/built-in/bui
 const built_in_for_loop_1 = require("../internal/process/functions/call/built-in/built-in-for-loop");
 const built_in_repeat_loop_1 = require("../internal/process/functions/call/built-in/built-in-repeat-loop");
 const built_in_while_loop_1 = require("../internal/process/functions/call/built-in/built-in-while-loop");
+const identifier_1 = require("./identifier");
 const assert_1 = require("../../util/assert");
 const built_in_replacement_1 = require("../internal/process/functions/call/built-in/built-in-replacement");
 const built_in_quote_1 = require("../internal/process/functions/call/built-in/built-in-quote");
 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 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");
 const built_in_apply_1 = require("../internal/process/functions/call/built-in/built-in-apply");
+const built_in_config_1 = require("./built-in-config");
+const default_builtin_config_1 = require("./default-builtin-config");
 exports.BuiltIn = '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 });
     if (config.returnsNthArgument !== undefined) {
         const arg = config.returnsNthArgument === 'last' ? processedArguments[args.length - 1] : processedArguments[config.returnsNthArgument];
         if (arg !== undefined) {
-            res.graph.addEdge(rootId, arg.entryPoint, { type: 8 /* EdgeType.Returns */ });
+            res.graph.addEdge(rootId, arg.entryPoint, edge_1.EdgeType.Returns);
         }
     }
     if (config.readAllArguments) {
         for (const arg of processedArguments) {
             if (arg) {
-                res.graph.addEdge(rootId, arg.entryPoint, { type: 1 /* EdgeType.Reads */ });
+                res.graph.addEdge(rootId, arg.entryPoint, edge_1.EdgeType.Reads);
             }
         }
     }
@@ -46,9 +51,8 @@ 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`);
-        (0, assert_1.guard)(!exports.BuiltInMemory.has(name), `Built-in ${name} already defined`);
         const d = [{
-                kind: 'built-in-function',
+                type: identifier_1.ReferenceType.BuiltInFunction,
                 definedAt: exports.BuiltIn,
                 controlDependencies: undefined,
                 processor: (name, args, rootId, data) => processor(name, args, rootId, data, config),
@@ -61,98 +65,26 @@ function registerBuiltInFunctions(both, names, processor, config) {
         }
     }
 }
-exports.registerBuiltInFunctions = registerBuiltInFunctions;
-/* registers all combinations of replacements */
-function registerReplacementFunctions(standardConfig, assignments, ...prefixes) {
-    for (const assignment of assignments) {
-        for (const prefix of prefixes) {
-            const effectiveName = `${prefix}${assignment}`;
-            (0, assert_1.guard)(!exports.BuiltInMemory.has(effectiveName), `Built-in ${effectiveName} already defined`);
-            const d = [{
-                    kind: 'built-in-function',
-                    definedAt: exports.BuiltIn,
-                    processor: (name, args, rootId, data) => (0, built_in_replacement_1.processReplacementFunction)(name, args, rootId, data, { ...standardConfig, assignmentOperator: assignment }),
-                    name: effectiveName,
-                    controlDependencies: undefined,
-                    nodeId: exports.BuiltIn
-                }];
-            exports.BuiltInMemory.set(effectiveName, d);
-            exports.EmptyBuiltInMemory.set(effectiveName, d);
-        }
-    }
-}
-exports.registerReplacementFunctions = registerReplacementFunctions;
-function registerSimpleFunctions(...names) {
-    registerBuiltInFunctions(false, names, defaultBuiltInProcessor, { readAllArguments: true });
-}
-function registerBuiltInConstant(both, name, value) {
-    (0, assert_1.guard)(!exports.BuiltInMemory.has(name), `Built-in ${name} already defined`);
-    const d = [{
-            kind: 'built-in-value',
-            definedAt: exports.BuiltIn,
-            controlDependencies: undefined,
-            value,
-            name,
-            nodeId: exports.BuiltIn
-        }];
-    exports.BuiltInMemory.set(name, d);
-    if (both) {
-        exports.EmptyBuiltInMemory.set(name, d);
-    }
-}
+exports.BuiltInProcessorMapper = {
+    'builtin:default': defaultBuiltInProcessor,
+    '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:library': built_in_library_1.processLibrary,
+    'builtin:assignment': built_in_assignment_1.processAssignment,
+    'builtin:special-bin-op': built_in_special_bin_op_1.processSpecialBinOp,
+    'builtin:pipe': built_in_pipe_1.processPipe,
+    'builtin:function-definition': built_in_function_definition_1.processFunctionDefinition,
+    'builtin:quote': built_in_quote_1.processQuote,
+    'builtin:for-loop': built_in_for_loop_1.processForLoop,
+    '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,
+};
 exports.BuiltInMemory = new Map();
 exports.EmptyBuiltInMemory = new Map();
-registerBuiltInConstant(true, 'NULL', null);
-registerBuiltInConstant(true, 'NA', null);
-registerBuiltInConstant(true, 'TRUE', true);
-registerBuiltInConstant(true, 'T', true);
-registerBuiltInConstant(true, 'FALSE', false);
-registerBuiltInConstant(true, 'F', false);
-registerSimpleFunctions('~', '+', '-', '*', '/', '^', '!', '?', '**', '==', '!=', '>', '<', '>=', '<=', '%%', '%/%', '%*%', '%in%', ':', 'list', 'c', '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', 'stop', 'is.null', 'plot', 'numeric', 'as.character', 'as.integer', 'as.logical', 'as.numeric', 'as.matrix', 'do.call', 'rbind', 'nrow', 'ncol', 'tryCatch', 'expression', 'factor', 'missing', 'as.data.frame', 'data.frame', 'na.omit', 'rownames', 'names', 'order', 'length', 'any', 'dim', 'matrix', 'cbind', 'nchar', 't');
-registerBuiltInFunctions(false, ['mapply', 'Mapply'], built_in_apply_1.processApply, { indexOfFunction: 0, nameOfFunctionArgument: 'FUN' });
-registerBuiltInFunctions(false, ['lapply', 'sapply', 'vapply'], built_in_apply_1.processApply, { indexOfFunction: 1, nameOfFunctionArgument: 'FUN' });
-/* functool wrappers */
-registerBuiltInFunctions(false, ['Lapply', 'Sapply', 'Vapply'], built_in_apply_1.processApply, { indexOfFunction: 1, nameOfFunctionArgument: 'FUN' });
-registerBuiltInFunctions(false, ['apply', 'tapply', 'Tapply'], built_in_apply_1.processApply, { indexOfFunction: 2, nameOfFunctionArgument: 'FUN' });
-registerBuiltInFunctions(false, ['print'], defaultBuiltInProcessor, { returnsNthArgument: 0, forceArgs: 'all' });
-registerBuiltInFunctions(true, ['('], defaultBuiltInProcessor, { returnsNthArgument: 0 });
-registerBuiltInFunctions(false, ['load', 'load_all', 'setwd', 'set.seed'], defaultBuiltInProcessor, { hasUnknownSideEffects: true, forceArgs: [true] });
-registerBuiltInFunctions(false, ['eval', 'body', 'formals', 'environment'], defaultBuiltInProcessor, { hasUnknownSideEffects: true, forceArgs: [true] });
-registerBuiltInFunctions(false, ['cat'], defaultBuiltInProcessor, { forceArgs: 'all' }); /* returns null */
-registerBuiltInFunctions(false, ['switch'], defaultBuiltInProcessor, {}); /* returns null */
-registerBuiltInFunctions(true, ['return'], defaultBuiltInProcessor, { returnsNthArgument: 0, cfg: 1 /* ExitPointType.Return */ });
-registerBuiltInFunctions(true, ['break'], defaultBuiltInProcessor, { cfg: 2 /* ExitPointType.Break */ });
-registerBuiltInFunctions(true, ['next'], defaultBuiltInProcessor, { cfg: 3 /* ExitPointType.Next */ });
-registerBuiltInFunctions(true, ['{'], built_in_expression_list_1.processExpressionList, {});
-registerBuiltInFunctions(false, ['source'], built_in_source_1.processSourceCall, { includeFunctionCall: true, forceFollow: false });
-registerBuiltInFunctions(true, ['[', '[['], built_in_access_1.processAccess, { treatIndicesAsString: false });
-registerBuiltInFunctions(true, ['$', '@'], built_in_access_1.processAccess, { treatIndicesAsString: true });
-registerBuiltInFunctions(true, ['if', 'ifelse'], built_in_if_then_else_1.processIfThenElse, {});
-registerBuiltInFunctions(false, ['get'], built_in_get_1.processGet, {});
-registerBuiltInFunctions(false, ['library', 'require'], built_in_library_1.processLibrary, {});
-registerBuiltInFunctions(true, ['<-', '='], built_in_assignment_1.processAssignment, { canBeReplacement: true });
-registerBuiltInFunctions(true, [':=', 'assign'], built_in_assignment_1.processAssignment, {});
-registerBuiltInFunctions(true, ['delayedAssign'], built_in_assignment_1.processAssignment, { quoteSource: true });
-registerBuiltInFunctions(true, ['<<-'], built_in_assignment_1.processAssignment, { superAssignment: true, canBeReplacement: true });
-registerBuiltInFunctions(true, ['->'], built_in_assignment_1.processAssignment, { swapSourceAndTarget: true, canBeReplacement: true });
-registerBuiltInFunctions(true, ['->>'], built_in_assignment_1.processAssignment, { superAssignment: true, swapSourceAndTarget: true, canBeReplacement: true });
-registerBuiltInFunctions(true, ['&&', '&'], built_in_special_bin_op_1.processSpecialBinOp, { lazy: true, evalRhsWhen: true });
-registerBuiltInFunctions(true, ['||', '|'], built_in_special_bin_op_1.processSpecialBinOp, { lazy: true, evalRhsWhen: false });
-registerBuiltInFunctions(true, ['|>', '%>%'], built_in_pipe_1.processPipe, {});
-registerBuiltInFunctions(true, ['function', '\\'], built_in_function_definition_1.processFunctionDefinition, {});
-registerBuiltInFunctions(true, ['quote', 'substitute', 'bquote'], built_in_quote_1.processQuote, { quoteArgumentsWithIndex: 0 });
-registerBuiltInFunctions(true, ['for'], built_in_for_loop_1.processForLoop, {});
-registerBuiltInFunctions(true, ['repeat'], built_in_repeat_loop_1.processRepeatLoop, {});
-registerBuiltInFunctions(true, ['while'], built_in_while_loop_1.processWhileLoop, {});
-registerBuiltInFunctions(false, ['options'], defaultBuiltInProcessor, { hasUnknownSideEffects: true, forceArgs: 'all' });
-registerBuiltInFunctions(false, ['on.exit', 'sys.on.exit', 'par'], defaultBuiltInProcessor, { hasUnknownSideEffects: true });
-registerBuiltInFunctions(false, ['setnames', 'setNames', 'setkey', 'setkeyv', 'setindex', 'setindexv', 'setattr', 'sink'], defaultBuiltInProcessor, { hasUnknownSideEffects: true });
-/* library and require is handled above */
-registerBuiltInFunctions(false, ['requireNamespace', 'loadNamespace', 'attachNamespace', 'asNamespace'], defaultBuiltInProcessor, { hasUnknownSideEffects: true });
-/* downloader and installer functions (R, devtools, BiocManager) */
-registerBuiltInFunctions(false, ['library.dynam', 'install.packages', 'install', 'install_github', 'install_gitlab', 'install_bitbucket', 'install_url', 'install_git', 'install_svn', 'install_local', 'install_version', 'update_packages'], defaultBuiltInProcessor, { hasUnknownSideEffects: true });
-/* weird env attachments */
-registerBuiltInFunctions(false, ['attach', 'detach', 'unname', 'rm', 'remove'], defaultBuiltInProcessor, { hasUnknownSideEffects: true });
-/* they are all mapped to `<-` but we separate super assignments */
-registerReplacementFunctions({ makeMaybe: true }, ['<-', '<<-'], '[', '[[', '$', '@', 'names', 'dimnames', 'attributes', 'attr', 'class', 'levels', 'rownames', 'colnames', 'body', 'environment', 'formals');
+(0, built_in_config_1.registerBuiltInDefinitions)(default_builtin_config_1.DefaultBuiltinConfig);
 //# sourceMappingURL=built-in.js.map

package/dataflow/environments/clone.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cloneEnvironmentInformation = void 0;
+exports.cloneEnvironmentInformation = cloneEnvironmentInformation;
 const environment_1 = require("./environment");
 function cloneEnvironment(environment, recurseParents) {
     if (environment === undefined) {
@@ -9,6 +9,7 @@ function cloneEnvironment(environment, recurseParents) {
     else if (environment.id === environment_1.BuiltInEnvironment.id) {
         return environment_1.BuiltInEnvironment;
     }
+    /* make sure the clone has the same id */
     const clone = new environment_1.Environment(recurseParents ? cloneEnvironment(environment.parent, recurseParents) : environment.parent);
     clone.memory = new Map(JSON.parse(JSON.stringify([...environment.memory])));
     return clone;
@@ -19,5 +20,4 @@ function cloneEnvironmentInformation(environment, recurseParents = true) {
         level: environment.level
     };
 }
-exports.cloneEnvironmentInformation = cloneEnvironmentInformation;
 //# sourceMappingURL=clone.js.map

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

@@ -0,0 +1,5 @@
+import type { BuiltInDefinitions } from './built-in-config';
+/**
+ * Contains the built-in definitions recognized by flowR
+ */
+export declare const DefaultBuiltinConfig: BuiltInDefinitions;