@eagleoutice/flowr 1.5.1 → 2.0.0

package/core/steps/pipeline-step.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Defines the {@link IPipelineStep} interface which specifies all data available for a single step.
+ *
+ * @module
+ */
+import type { MergeableRecord } from '../../util/objects';
+import type { InternalStepPrinter, IPipelineStepPrinter, StepOutputFormat } from '../print/print';
+/**
+ * This represents the format of a step processor which retrieves two things:
+ *
+ * 1) the input configuration as passed to the {@link PipelineExecutor}.
+ * 2) the output produced by the previous steps.
+ *
+ * Please be aware, that if the respective information is available is not ensured by the type system but rather
+ * ensured at runtime by your dependencies. If you want to make sure, that the information is present,
+ * list all steps that you require as your {@link IPipelineStepOrder#dependencies|dependencies}, even if they would be
+ * already covered transitively.
+ */
+export type StepProcessingFunction = (results: Record<string, unknown>, input: Record<string, unknown>) => unknown;
+/**
+ * This represents the required execution frequency of a step.
+ */
+export declare const enum PipelineStepStage {
+    /** This step has to be executed once per file */
+    OncePerFile = 0,
+    /** This step has to be executed once per request (e.g., slice for a given variable) */
+    OncePerRequest = 1
+}
+/** Name of a single {@link IPipelineStep|step} in a pipeline (branded to avoid type-mishaps). */
+export type PipelineStepName = string & {
+    __brand?: 'StepName';
+};
+/**
+ * Contains the data to specify the order of {@link IPipelineStep|steps} in a pipeline.
+ */
+export interface IPipelineStepOrder<Name extends PipelineStepName = PipelineStepName> {
+    /**
+     * Name of the respective step, it does not have to be unique in general but only unique per-pipeline.
+     * In other words, you can have multiple steps with a name like `parse` as long as you use only one of them in a given pipeline.
+     * This is, because these names are required in the {@link IPipelineStep#dependencies} field to refer to other steps this one relies on.
+     */
+    readonly name: Name;
+    /**
+     * Give the names of other steps this one requires to be completed as a prerequisite (e.g., to gain access to their input).
+     * Does not have to be transitive, this will be checked by the scheduler of the pipeline.
+     */
+    readonly dependencies: readonly PipelineStepName[];
+    readonly executed: PipelineStepStage;
+    /**
+     * This is similar to {@link dependencies}, but is used to say that a given step _decorates_ another one.
+     * This imbues two requirements:
+     * The step must take the output of the decorated step as input, and produce the same output as the decorated step.
+     *
+     * If so, it is ensured that _this_ step is executed _after_ the step it decorates, but before any step that depends on it.
+     */
+    readonly decorates?: PipelineStepName;
+}
+/**
+ * Defines what is to be known of a single step in a pipeline.
+ * It wraps around a single {@link IPipelineStep#processor|processor} function, providing additional information.
+ * Steps will be executed synchronously, in-sequence, based on their {@link IPipelineStep#dependencies|dependencies}.
+ */
+export interface IPipelineStep<Name extends PipelineStepName = PipelineStepName, Fn extends StepProcessingFunction = (...args: any[]) => any> extends MergeableRecord, IPipelineStepOrder<Name> {
+    /** Human-readable name of this step */
+    readonly humanReadableName: string;
+    /** Human-readable description of this step */
+    readonly description: string;
+    /** The main processor that essentially performs the logic of this step */
+    readonly processor: (...input: Parameters<Fn>) => ReturnType<Fn>;
+    /**
+     * How to visualize the results of the respective step to the user?
+     */
+    readonly printer: {
+        [K in StepOutputFormat]?: IPipelineStepPrinter<Fn, K, never[]>;
+    } & {
+        [StepOutputFormat.Internal]: InternalStepPrinter<Fn>;
+    };
+    /**
+     * Input configuration required to perform the respective steps.
+     * Required inputs of dependencies do not have to, but can be repeated.
+     * <p>
+     * Use the pattern `undefined as unknown as T` to indicate that the value is required but not provided.
+     */
+    readonly requiredInput: object;
+}

package/core/steps/pipeline-step.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Defines the {@link IPipelineStep} interface which specifies all data available for a single step.
+ *
+ * @module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=pipeline-step.js.map

package/dataflow/environments/append.d.ts

@@ -2,7 +2,7 @@ import type { REnvironmentInformation } from './environment';
 /**
  * Adds all writes of `next` to `base` (i.e., the operations of `next` *might* happen).
  */
-export declare function appendEnvironments(base: REnvironmentInformation, next: REnvironmentInformation | undefined): REnvironmentInformation;
-export declare function appendEnvironments(base: REnvironmentInformation | undefined, next: REnvironmentInformation): REnvironmentInformation;
-export declare function appendEnvironments(base: undefined, next: undefined): undefined;
-export declare function appendEnvironments(base: REnvironmentInformation | undefined, next: REnvironmentInformation | undefined): REnvironmentInformation | undefined;
+export declare function appendEnvironment(base: REnvironmentInformation, next: REnvironmentInformation | undefined): REnvironmentInformation;
+export declare function appendEnvironment(base: REnvironmentInformation | undefined, next: REnvironmentInformation): REnvironmentInformation;
+export declare function appendEnvironment(base: undefined, next: undefined): undefined;
+export declare function appendEnvironment(base: REnvironmentInformation | undefined, next: REnvironmentInformation | undefined): REnvironmentInformation | undefined;

package/dataflow/environments/append.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.appendEnvironments = void 0;
+exports.appendEnvironment = void 0;
 const assert_1 = require("../../util/assert");
 const environment_1 = require("./environment");
 function uniqueMergeValues(old, value) {
@@ -26,12 +26,12 @@ function appendIEnvironmentWith(base, next) {
             map.set(key, value);
         }
     }
-    const parent = base.parent === undefined ? undefined : appendIEnvironmentWith(base.parent, next.parent);
+    const parent = base.parent === environment_1.BuiltInEnvironment ? environment_1.BuiltInEnvironment : appendIEnvironmentWith(base.parent, next.parent);
     const out = new environment_1.Environment(base.name, parent);
     out.memory = map;
     return out;
 }
-function appendEnvironments(base, next) {
+function appendEnvironment(base, next) {
     if (base === undefined) {
         return next;
     }
@@ -44,5 +44,5 @@ function appendEnvironments(base, next) {
         level: base.level,
     };
 }
-exports.appendEnvironments = appendEnvironments;
+exports.appendEnvironment = appendEnvironment;
 //# sourceMappingURL=append.js.map

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

@@ -0,0 +1,25 @@
+import type { DataflowProcessorInformation } from '../processor';
+import type { DataflowInformation } from '../info';
+import type { Identifier, IdentifierDefinition, IdentifierReference } from './identifier';
+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';
+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';
+    definedAt: typeof BuiltIn;
+    processor: BuiltInIdentifierProcessor;
+}
+export interface BuiltInIdentifierConstant<T = unknown> extends IdentifierReference {
+    kind: 'built-in-value';
+    definedAt: typeof BuiltIn;
+    value: T;
+}
+export declare function registerBuiltInFunctions<Config, Proc extends BuiltInIdentifierProcessorWithConfig<Config>>(names: readonly Identifier[], processor: Proc, config: Config): void;
+export declare function registerReplacementFunctions(standardConfig: {
+    makeMaybe?: boolean;
+}, assignments: readonly ('<-' | '<<-')[], ...prefixes: readonly Identifier[]): void;
+export declare const BuiltInMemory: Map<Identifier, IdentifierDefinition[]>;

package/dataflow/environments/built-in.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuiltInMemory = exports.registerReplacementFunctions = exports.registerBuiltInFunctions = exports.BuiltIn = void 0;
+const known_call_handling_1 = require("../internal/process/functions/call/known-call-handling");
+const built_in_source_1 = require("../internal/process/functions/call/built-in/built-in-source");
+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");
+const built_in_assignment_1 = require("../internal/process/functions/call/built-in/built-in-assignment");
+const built_in_logical_bin_op_1 = require("../internal/process/functions/call/built-in/built-in-logical-bin-op");
+const built_in_pipe_1 = require("../internal/process/functions/call/built-in/built-in-pipe");
+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 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 built_in_library_1 = require("../internal/process/functions/call/built-in/built-in-library");
+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 });
+    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 */ });
+        }
+    }
+    if (config.readAllArguments) {
+        for (const arg of processedArguments) {
+            if (arg) {
+                res.graph.addEdge(rootId, arg.entryPoint, { type: 1 /* EdgeType.Reads */ });
+            }
+        }
+    }
+    if (config.cfg !== undefined) {
+        res.exitPoints = [...res.exitPoints, { type: config.cfg, nodeId: rootId, controlDependencies: data.controlDependencies }];
+    }
+    return res;
+}
+function registerBuiltInFunctions(names, processor, config) {
+    for (const name of names) {
+        (0, assert_1.guard)(!exports.BuiltInMemory.has(name), `Built-in ${name} already defined`);
+        exports.BuiltInMemory.set(name, [{
+                kind: 'built-in-function',
+                definedAt: exports.BuiltIn,
+                controlDependencies: undefined,
+                processor: (name, args, rootId, data) => processor(name, args, rootId, data, config),
+                name,
+                nodeId: exports.BuiltIn
+            }]);
+    }
+}
+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`);
+            exports.BuiltInMemory.set(effectiveName, [{
+                    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.registerReplacementFunctions = registerReplacementFunctions;
+function registerSimpleFunctions(...names) {
+    registerBuiltInFunctions(names, defaultBuiltInProcessor, { readAllArguments: true });
+}
+function registerBuiltInConstant(name, value) {
+    (0, assert_1.guard)(!exports.BuiltInMemory.has(name), `Built-in ${name} already defined`);
+    exports.BuiltInMemory.set(name, [{
+            kind: 'built-in-value',
+            definedAt: exports.BuiltIn,
+            controlDependencies: undefined,
+            value,
+            name,
+            nodeId: exports.BuiltIn
+        }]);
+}
+exports.BuiltInMemory = new Map();
+registerBuiltInConstant('NULL', null);
+registerBuiltInConstant('NA', null);
+registerBuiltInConstant('TRUE', true);
+registerBuiltInConstant('T', true);
+registerBuiltInConstant('FALSE', false);
+registerBuiltInConstant('F', false);
+registerSimpleFunctions('~', '+', '-', '*', '/', '^', '!', '?', '**', '==', '!=', '>', '<', '>=', '<=', '%%', '%/%', '%*%', ':', 'list');
+registerBuiltInFunctions(['cat', 'switch'], defaultBuiltInProcessor, {}); /* returns null */
+registerBuiltInFunctions(['print', '('], defaultBuiltInProcessor, { returnsNthArgument: 0 });
+registerBuiltInFunctions(['return'], defaultBuiltInProcessor, { returnsNthArgument: 0, cfg: 1 /* ExitPointType.Return */ });
+registerBuiltInFunctions(['break'], defaultBuiltInProcessor, { cfg: 2 /* ExitPointType.Break */ });
+registerBuiltInFunctions(['next'], defaultBuiltInProcessor, { cfg: 3 /* ExitPointType.Next */ });
+registerBuiltInFunctions(['{'], built_in_expression_list_1.processExpressionList, {});
+registerBuiltInFunctions(['source'], built_in_source_1.processSourceCall, {});
+registerBuiltInFunctions(['[', '[['], built_in_access_1.processAccess, { treatIndicesAsString: false });
+registerBuiltInFunctions(['$', '@'], built_in_access_1.processAccess, { treatIndicesAsString: true });
+registerBuiltInFunctions(['if'], built_in_if_then_else_1.processIfThenElse, {});
+registerBuiltInFunctions(['get'], built_in_get_1.processGet, {});
+registerBuiltInFunctions(['library'], built_in_library_1.processLibrary, {});
+registerBuiltInFunctions(['<-', '='], built_in_assignment_1.processAssignment, { canBeReplacement: true });
+registerBuiltInFunctions([':=', 'assign'], built_in_assignment_1.processAssignment, {});
+registerBuiltInFunctions(['delayedAssign'], built_in_assignment_1.processAssignment, { quoteSource: true });
+registerBuiltInFunctions(['<<-'], built_in_assignment_1.processAssignment, { superAssignment: true, canBeReplacement: true });
+registerBuiltInFunctions(['->'], built_in_assignment_1.processAssignment, { swapSourceAndTarget: true, canBeReplacement: true });
+registerBuiltInFunctions(['->>'], built_in_assignment_1.processAssignment, { superAssignment: true, swapSourceAndTarget: true, canBeReplacement: true });
+registerBuiltInFunctions(['&&', '||', '&', '|'], built_in_logical_bin_op_1.processSpecialBinOp, { lazy: true });
+registerBuiltInFunctions(['|>', '%>%'], built_in_pipe_1.processPipe, {});
+registerBuiltInFunctions(['function', '\\'], built_in_function_definition_1.processFunctionDefinition, {});
+registerBuiltInFunctions(['quote', 'substitute', 'bquote'], built_in_quote_1.processQuote, { quoteArgumentsWithIndex: 0 });
+registerBuiltInFunctions(['for'], built_in_for_loop_1.processForLoop, {});
+registerBuiltInFunctions(['repeat'], built_in_repeat_loop_1.processRepeatLoop, {});
+registerBuiltInFunctions(['while'], built_in_while_loop_1.processWhileLoop, {});
+/* they are all mapped to `<-` but we separate super assignments */
+registerReplacementFunctions({ makeMaybe: true }, ['<-', '<<-'], '[', '[[', '$', '@', 'names', 'dimnames', 'attributes', 'attr', 'class', 'levels', 'rownames', 'colnames');
+//# sourceMappingURL=built-in.js.map

package/dataflow/environments/clone.d.ts

@@ -0,0 +1,2 @@
+import type { REnvironmentInformation } from './environment';
+export declare function cloneEnvironmentInformation(environment: REnvironmentInformation, recurseParents?: boolean): REnvironmentInformation;

package/dataflow/environments/clone.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloneEnvironmentInformation = void 0;
+const environment_1 = require("./environment");
+function cloneEnvironment(environment, recurseParents) {
+    if (environment === undefined) {
+        return undefined;
+    }
+    else if (environment.id === environment_1.BuiltInEnvironment.id) {
+        return environment_1.BuiltInEnvironment;
+    }
+    const clone = new environment_1.Environment(environment.name, recurseParents ? cloneEnvironment(environment.parent, recurseParents) : environment.parent);
+    clone.memory = new Map(JSON.parse(JSON.stringify([...environment.memory])));
+    return clone;
+}
+function cloneEnvironmentInformation(environment, recurseParents = true) {
+    return {
+        current: cloneEnvironment(environment.current, recurseParents),
+        level: environment.level
+    };
+}
+exports.cloneEnvironmentInformation = cloneEnvironmentInformation;
+//# sourceMappingURL=clone.js.map

package/dataflow/environments/{register.d.ts → define.d.ts}

@@ -1,7 +1,7 @@
-import type { IdentifierDefinition, REnvironmentInformation } from './environment';
-import type { DataflowScopeName } from './scopes';
+import type { REnvironmentInformation } from './environment';
+import type { IdentifierDefinition } from './identifier';
 /**
  * Insert the given `definition` --- defined within the given scope --- into the passed along `environments` will take care of propagation.
  * Does not modify the passed along `environments` in-place! It returns the new reference.
  */
-export declare function define(definition: IdentifierDefinition, withinScope: DataflowScopeName, environments: REnvironmentInformation): REnvironmentInformation;
+export declare function define(definition: IdentifierDefinition, superAssign: boolean | undefined, environment: REnvironmentInformation): REnvironmentInformation;

package/dataflow/environments/define.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.define = void 0;
+const assert_1 = require("../../util/assert");
+const environment_1 = require("./environment");
+const clone_1 = require("./clone");
+function defInEnv(newEnvironments, name, definition) {
+    const existing = newEnvironments.memory.get(name);
+    // check if it is maybe or not
+    if (existing === undefined || definition.controlDependencies === undefined) {
+        newEnvironments.memory.set(name, [definition]);
+    }
+    else {
+        existing.push(definition);
+    }
+}
+/**
+ * Insert the given `definition` --- defined within the given scope --- into the passed along `environments` will take care of propagation.
+ * Does not modify the passed along `environments` in-place! It returns the new reference.
+ */
+function define(definition, superAssign, environment) {
+    const name = definition.name;
+    (0, assert_1.guard)(name !== undefined, () => `Name must be defined, but isn't for ${JSON.stringify(definition)}`);
+    let newEnvironment;
+    if (superAssign) {
+        newEnvironment = (0, clone_1.cloneEnvironmentInformation)(environment, true);
+        let current = newEnvironment.current;
+        let last = undefined;
+        let found = false;
+        do {
+            if (current.memory.has(name)) {
+                current.memory.set(name, [definition]);
+                found = true;
+                break;
+            }
+            last = current;
+            current = current.parent;
+        } while (current.id !== environment_1.BuiltInEnvironment.id);
+        if (!found) {
+            (0, assert_1.guard)(last !== undefined, () => `Could not find global scope for ${name}`);
+            last.memory.set(name, [definition]);
+        }
+    }
+    else {
+        newEnvironment = (0, clone_1.cloneEnvironmentInformation)(environment, false);
+        defInEnv(newEnvironment.current, name, definition);
+    }
+    return newEnvironment;
+}
+exports.define = define;
+//# sourceMappingURL=define.js.map

package/dataflow/environments/diff.d.ts

@@ -0,0 +1,6 @@
+import type { GenericDifferenceInformation, WriteableDifferenceReport } from '../../util/diff';
+import type { IEnvironment, REnvironmentInformation } from './environment';
+import type { IdentifierReference } from './identifier';
+export declare function diffIdentifierReferences<Report extends WriteableDifferenceReport>(a: IdentifierReference | undefined, b: IdentifierReference | undefined, info: GenericDifferenceInformation<Report>): void;
+export declare function diffEnvironment<Report extends WriteableDifferenceReport>(a: IEnvironment | undefined, b: IEnvironment | undefined, info: GenericDifferenceInformation<Report>): void;
+export declare function diffEnvironmentInformation<Report extends WriteableDifferenceReport>(a: REnvironmentInformation | undefined, b: REnvironmentInformation | undefined, info: GenericDifferenceInformation<Report>): void;

package/dataflow/environments/diff.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffEnvironmentInformation = exports.diffEnvironment = exports.diffIdentifierReferences = void 0;
+const diff_1 = require("../../util/diff");
+const json_1 = require("../../util/json");
+const arrays_1 = require("../../util/arrays");
+function diffIdentifierReferences(a, b, info) {
+    if (a === undefined || b === undefined) {
+        if (a !== b) {
+            info.report.addComment(`${info.position}Different identifier references: ${info.leftname}: ${JSON.stringify(a, json_1.jsonReplacer)} vs. ${info.rightname}: ${JSON.stringify(b, json_1.jsonReplacer)}`);
+        }
+        return;
+    }
+    if (a.name !== b.name) {
+        info.report.addComment(`${info.position}Different identifier names: ${info.leftname}: ${a.name} vs. ${info.rightname}: ${b.name}`);
+    }
+    if (a.nodeId !== b.nodeId) {
+        info.report.addComment(`${info.position}Different nodeIds: ${info.leftname}: ${a.nodeId} vs. ${info.rightname}: ${b.nodeId}`);
+    }
+    if (!(0, arrays_1.arrayEqual)(a.controlDependencies, b.controlDependencies)) {
+        info.report.addComment(`${info.position}Different control dependency: ${info.leftname}: ${JSON.stringify(a.controlDependencies)} vs. ${info.rightname}: ${JSON.stringify(b.controlDependencies)}`);
+    }
+}
+exports.diffIdentifierReferences = diffIdentifierReferences;
+function diffMemory(a, b, info) {
+    for (const [key, value] of a.memory) {
+        const value2 = b.memory.get(key);
+        if (value2 === undefined || value.length !== value2.length) {
+            info.report.addComment(`${info.position}Different definitions for ${key}. ${info.leftname}: ${JSON.stringify(value, json_1.jsonReplacer)} vs. ${info.rightname}: ${JSON.stringify(value2, json_1.jsonReplacer)}`);
+            continue;
+        }
+        // we sort both value arrays by their id so that we have no problems with differently ordered arrays (which have no impact)
+        const sorted = [...value].sort((a, b) => String(a.nodeId).localeCompare(String(b.nodeId)));
+        const sorted2 = [...value2].sort((a, b) => String(a.nodeId).localeCompare(String(b.nodeId)));
+        for (let i = 0; i < value.length; ++i) {
+            const aVal = sorted[i];
+            const bVal = sorted2[i];
+            if (aVal.name !== bVal.name) {
+                info.report.addComment(`${info.position}Different names for ${key}. ${info.leftname}: ${aVal.name} vs. ${info.rightname}: ${bVal.name}`);
+            }
+            if (aVal.nodeId !== bVal.nodeId) {
+                info.report.addComment(`${info.position}Different ids for ${key}. ${info.leftname}: ${aVal.nodeId} vs. ${info.rightname}: ${bVal.nodeId}`);
+            }
+            if (!(0, arrays_1.arrayEqual)(aVal.controlDependencies, bVal.controlDependencies)) {
+                info.report.addComment(`${info.position}Different controlDependency for ${key} (${aVal.nodeId}). ${info.leftname}: ${JSON.stringify(aVal.controlDependencies)} vs. ${info.rightname}: ${JSON.stringify(bVal.controlDependencies)}`);
+            }
+            if (aVal.definedAt !== bVal.definedAt) {
+                info.report.addComment(`${info.position}Different definition ids (definedAt) for ${key} (${aVal.nodeId}). ${info.leftname}: ${aVal.definedAt} vs. ${info.rightname}: ${bVal.definedAt}`);
+            }
+            if (aVal.kind !== bVal.kind) {
+                info.report.addComment(`${info.position}Different kinds for ${key} (${aVal.nodeId}). ${info.leftname}: ${aVal.kind} vs. ${info.rightname}: ${bVal.kind}`);
+            }
+        }
+    }
+}
+function diffEnvironment(a, b, info) {
+    if (a === undefined || b === undefined) {
+        if (a !== b) {
+            info.report.addComment(`${info.position}Different environments. ${info.leftname}: ${a !== undefined ? 'present' : 'undefined'} vs. ${info.rightname}: ${b !== undefined ? 'present' : 'undefined'}`);
+        }
+        return;
+    }
+    if (a.name !== b.name) {
+        info.report.addComment(`${info.position}Different environment names. ${info.leftname}: ${a.name}  vs. ${info.rightname}: ${b.name}`);
+    }
+    if (a.memory.size !== b.memory.size) {
+        info.report.addComment(`${info.position}Different environment sizes. ${info.leftname}: ${a.memory.size} vs. ${info.rightname}: ${b.memory.size}`);
+        (0, diff_1.setDifference)(new Set([...a.memory.keys()]), new Set([...b.memory.keys()]), {
+            ...info,
+            position: `${info.position}Key comparison. `
+        });
+    }
+    diffMemory(a, b, info);
+    diffEnvironment(a.parent, b.parent, { ...info, position: `${info.position}Parents of ${a.id} & ${b.id}. ` });
+}
+exports.diffEnvironment = diffEnvironment;
+function diffEnvironmentInformation(a, b, info) {
+    if (a === undefined || b === undefined) {
+        info.report.addComment(`${info.position}Different environments: ${JSON.stringify(a, json_1.jsonReplacer)} vs. ${JSON.stringify(b, json_1.jsonReplacer)}`);
+        return;
+    }
+    diffEnvironment(a.current, b.current, info);
+}
+exports.diffEnvironmentInformation = diffEnvironmentInformation;
+//# sourceMappingURL=diff.js.map

package/dataflow/environments/environment.d.ts

@@ -4,48 +4,17 @@
  *
  * @module
  */
-import type { NodeId } from '../../r-bridge';
-import type { DataflowGraph, DataflowGraphEdgeAttribute } from '../graph';
-import type { DataflowScopeName } from './scopes';
-import type { GenericDifferenceInformation } from '../../util/diff';
-/** identifiers are branded to avoid confusion with other string-like types */
-export type Identifier = string & {
-    __brand?: 'identifier';
-};
-export declare const BuiltIn = "built-in";
-/**
- * Stores the definition of an identifier within an {@link IEnvironment}
- */
-export interface IdentifierDefinition extends IdentifierReference {
-    kind: 'function' | 'variable' | 'parameter' | 'unknown' | 'built-in-function' | 'argument';
-    /** The assignment (or whatever, like `assign` function call) node which ultimately defined this identifier */
-    definedAt: NodeId;
-}
-/**
- * Something like `a` in `b <- a`.
- * Without any surrounding information, `a` will produce the
- * identifier reference `a` in the current scope (like the global environment).
- * Similarly, `b` will create a reference.
- */
-export interface IdentifierReference {
-    name: Identifier;
-    scope: DataflowScopeName;
-    /** Node which represents the reference in the AST */
-    nodeId: NodeId;
-    /**
-   * Is this reference used in every execution path of the program or only if some of them. This can be too-conservative regarding `maybe`.
-   * For example, if we can not detect `if(FALSE)`, this will be `maybe` even if we could statically determine, that the `then` branch is never executed.
-   */
-    used: DataflowGraphEdgeAttribute;
-}
-export declare function diffIdentifierReferences(a: IdentifierReference, b: IdentifierReference, info: GenericDifferenceInformation): void;
-export declare function makeAllMaybe(references: IdentifierReference[] | undefined, graph: DataflowGraph, environments: REnvironmentInformation): IdentifierReference[];
+import type { Identifier, IdentifierDefinition, IdentifierReference } from './identifier';
+import type { DataflowGraph } from '../graph/graph';
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+export declare function makeReferenceMaybe(ref: IdentifierReference, graph: DataflowGraph, environments: REnvironmentInformation, includeDefs: boolean, defaultCd?: NodeId | undefined): IdentifierReference;
+export declare function makeAllMaybe(references: readonly IdentifierReference[] | undefined, graph: DataflowGraph, environments: REnvironmentInformation, includeDefs: boolean, defaultCd?: NodeId | undefined): IdentifierReference[];
 export interface IEnvironment {
     /** unique and internally generated identifier -- will not be used for comparison but assists debugging for tracking identities */
     readonly id: string;
     readonly name: string;
     /** Lexical parent of the environment, if any (can be manipulated by R code) */
-    parent?: IEnvironment;
+    parent: IEnvironment;
     /**
    * Maps to exactly one definition of an identifier if the source is known, otherwise to a list of all possible definitions
    */
@@ -54,9 +23,9 @@ export interface IEnvironment {
 export declare class Environment implements IEnvironment {
     readonly name: string;
     readonly id: string;
-    parent?: IEnvironment;
+    parent: IEnvironment;
     memory: Map<Identifier, IdentifierDefinition[]>;
-    constructor(name: string, parent?: IEnvironment);
+    constructor(name: string, parent: IEnvironment);
 }
 /**
  * First of all, yes, R stores its environments differently, potentially even with a different differentiation between
@@ -71,8 +40,6 @@ export interface REnvironmentInformation {
     /** nesting level of the environment, will be `0` for the global/root environment */
     readonly level: number;
 }
-export declare const DefaultEnvironmentMemory: Map<Identifier, IdentifierDefinition[]>;
+export declare const BuiltInEnvironment: Environment;
+export declare const GLOBAL_ENV_NAME = "global";
 export declare function initializeCleanEnvironments(): REnvironmentInformation;
-export declare function diffEnvironment(a: IEnvironment | undefined, b: IEnvironment | undefined, info: GenericDifferenceInformation): void;
-export declare function diffEnvironments(a: REnvironmentInformation | undefined, b: REnvironmentInformation | undefined, info: GenericDifferenceInformation): void;
-export declare function cloneEnvironments(environment: REnvironmentInformation, recurseParents?: boolean): REnvironmentInformation;