@eagleoutice/flowr 2.6.2 → 2.7.0

package/dataflow/environments/clone.js

@@ -1,29 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cloneEnvironmentInformation = cloneEnvironmentInformation;
-const environment_1 = require("./environment");
-function cloneEnvironment(environment, recurseParents) {
-    if (environment === undefined) {
-        return undefined;
-    }
-    else if (environment.builtInEnv) {
-        return environment; // do not clone the built-in environment
-    }
-    /* make sure the clone has the same id */
-    const clone = new environment_1.Environment(recurseParents ? cloneEnvironment(environment.parent, recurseParents) : environment.parent, environment.builtInEnv);
-    clone.memory = new Map(JSON.parse(JSON.stringify([...environment.memory])));
-    return clone;
-}
 /**
  * Produce a clone of the given environment information.
  * @param environment        - The environment information to clone.
- * @param builtInEnvironment - The built-in environment
  * @param recurseParents     - Whether to clone the parent environments as well.
  */
-function cloneEnvironmentInformation(environment, recurseParents = true) {
+function cloneEnvironmentInformation({ current, level }, recurseParents = true) {
     return {
-        current: cloneEnvironment(environment.current, recurseParents),
-        level: environment.level
+        current: current.clone(recurseParents),
+        level
     };
 }
 //# sourceMappingURL=clone.js.map

package/dataflow/environments/define.d.ts

@@ -1,12 +1,16 @@
 import type { REnvironmentInformation } from './environment';
-import type { IdentifierDefinition, InGraphIdentifierDefinition } from './identifier';
+import type { Identifier, IdentifierDefinition, InGraphIdentifierDefinition } from './identifier';
 import type { FlowrConfigOptions } from '../../config';
 /**
  * assumes: existing is not undefined, the overwrite has indices
  */
-export declare function mergeDefinitions(existing: readonly IdentifierDefinition[], definition: InGraphIdentifierDefinition): InGraphIdentifierDefinition[];
+export declare function mergeDefinitionsForPointer(existing: readonly IdentifierDefinition[], definition: InGraphIdentifierDefinition): InGraphIdentifierDefinition[];
 /**
  * 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.
+ * @see {@link Environment#define}      - for details on how (local) definitions are handled.
+ * @see {@link Environment#defineSuper} - for details on how (super) definitions are handled.
  */
-export declare function define(definition: IdentifierDefinition, superAssign: boolean | undefined, environment: REnvironmentInformation, config: FlowrConfigOptions): REnvironmentInformation;
+export declare function define(definition: IdentifierDefinition & {
+    name: Identifier;
+}, superAssign: boolean | undefined, { level, current }: REnvironmentInformation, config: FlowrConfigOptions): REnvironmentInformation;

package/dataflow/environments/define.js

@@ -1,39 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeDefinitions = mergeDefinitions;
+exports.mergeDefinitionsForPointer = mergeDefinitionsForPointer;
 exports.define = define;
 const assert_1 = require("../../util/assert");
-const clone_1 = require("./clone");
 const vertex_1 = require("../graph/vertex");
-function defInEnv(newEnvironments, name, definition, config) {
-    const existing = newEnvironments.memory.get(name);
-    // When there are defined indices, merge the definitions
-    const inGraphDefinition = definition;
-    if (config.solver.pointerTracking &&
-        existing !== undefined &&
-        inGraphDefinition.controlDependencies === undefined) {
-        if (inGraphDefinition.indicesCollection !== undefined) {
-            newEnvironments.memory.set(name, mergeDefinitions(existing, inGraphDefinition));
-            return;
-        }
-        else if (existing?.flatMap(i => i.indicesCollection ?? []).length > 0) {
-            // When indices couldn't be resolved, but indices where defined before, just add the definition
-            existing.push(definition);
-            return;
-        }
-    }
-    // check if it is maybe or not
-    if (existing === undefined || definition.controlDependencies === undefined) {
-        newEnvironments.memory.set(name, [definition]);
-    }
-    else {
-        existing.push(definition);
-    }
-}
 /**
  * assumes: existing is not undefined, the overwrite has indices
  */
-function mergeDefinitions(existing, definition) {
+function mergeDefinitionsForPointer(existing, definition) {
     // When new definition is not a single index, e.g., a list redefinition, then reset existing definition
     if (definition.indicesCollection?.some(indices => indices.isContainer)) {
         return [definition];
@@ -119,34 +93,13 @@ function overwriteContainerIndices(existingIndices, overwriteIndex) {
 /**
  * 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.
+ * @see {@link Environment#define}      - for details on how (local) definitions are handled.
+ * @see {@link Environment#defineSuper} - for details on how (super) definitions are handled.
  */
-function define(definition, superAssign, environment, config) {
-    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.builtInEnv);
-        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, config);
-    }
-    return newEnvironment;
+function define(definition, superAssign, { level, current }, config) {
+    return {
+        level,
+        current: superAssign ? current.defineSuper(definition) : current.define(definition, config),
+    };
 }
 //# sourceMappingURL=define.js.map

package/dataflow/environments/diff.js

@@ -33,8 +33,8 @@ function diffMemory(a, b, info) {
             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)));
+        const sorted = value.slice().sort((a, b) => String(a.nodeId).localeCompare(String(b.nodeId)));
+        const sorted2 = value2.slice().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];
@@ -69,7 +69,7 @@ function diffEnvironment(a, b, info, depth) {
     }
     if (a.memory.size !== b.memory.size) {
         info.report.addComment(`${info.position}[at level: ${depth}] Different number of definitions in environment. ${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()]), {
+        (0, diff_1.setDifference)(new Set(a.memory.keys()), new Set(b.memory.keys()), {
             ...info,
             position: `${info.position}[at level: ${depth}] Key comparison. `
         });

package/dataflow/environments/environment.d.ts

@@ -1,20 +1,8 @@
-/**
- * Provides an environment structure similar to R.
- * This allows the dataflow to hold current definition locations for variables, based on the current scope.
- * @module
- */
-import type { IdentifierReference } from './identifier';
-import type { DataflowGraph } from '../graph/graph';
-import type { ControlDependency } from '../info';
 import type { BuiltInMemory } from './built-in';
-/**
- * Marks the reference as maybe (i.e., as controlled by a set of {@link IdentifierReference#controlDependencies|control dependencies}).
- */
-export declare function makeReferenceMaybe(ref: IdentifierReference, graph: DataflowGraph, environments: REnvironmentInformation, includeDefs: boolean, defaultCd?: ControlDependency | undefined): IdentifierReference;
-/**
- *
- */
-export declare function makeAllMaybe(references: readonly IdentifierReference[] | undefined, graph: DataflowGraph, environments: REnvironmentInformation, includeDefs: boolean, defaultCd?: ControlDependency | undefined): IdentifierReference[];
+import type { Identifier, IdentifierDefinition } from './identifier';
+import type { ControlDependency } from '../info';
+import type { FlowrConfigOptions } from '../../config';
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 /** A single entry/scope within an {@link REnvironmentInformation} */
 export interface IEnvironment {
     /** Unique and internally generated identifier -- will not be used for comparison but helps with debugging for tracking identities */
@@ -28,6 +16,12 @@ export interface IEnvironment {
      */
     builtInEnv?: true | undefined;
 }
+type Jsonified = {
+    id: NodeId;
+    parent: Jsonified | undefined;
+    builtInEnv?: true;
+    memory: BuiltInMemory;
+};
 /**
  * Please use this function only if you do not know the object type.
  * Otherwise, rely on {@link IEnvironment#builtInEnv}
@@ -36,14 +30,43 @@ export declare function isDefaultBuiltInEnvironment(obj: unknown): boolean;
 /** @see REnvironmentInformation */
 export declare class Environment implements IEnvironment {
     readonly id: number;
-    parent: IEnvironment;
+    parent: Environment;
     memory: BuiltInMemory;
+    cache?: BuiltInMemory;
     builtInEnv?: true;
-    constructor(parent: IEnvironment, isBuiltInDefault?: true | undefined);
-}
-export interface WorkingDirectoryReference {
-    readonly path: string;
-    readonly controlDependencies: ControlDependency[] | undefined;
+    constructor(parent: Environment, isBuiltInDefault?: true | undefined);
+    /**
+     * Create a deep clone of this environment.
+     * @param recurseParents     - Whether to also clone parent environments
+     */
+    clone(recurseParents: boolean): Environment;
+    /**
+     * Define a new identifier definition within this environment.
+     * @param definition  - The definition to add.
+     * @param config      - The flowr configuration options.
+     */
+    define(definition: IdentifierDefinition & {
+        name: Identifier;
+    }, { solver: { pointerTracking } }: FlowrConfigOptions): Environment;
+    defineSuper(definition: IdentifierDefinition & {
+        name: Identifier;
+    }): Environment;
+    /**
+     * Assumes, that all definitions within other replace those within this environment (given the same name).
+     * <b>But</b> if all definitions within other are maybe, then they are appended to the current definitions (updating them to be `maybe` from now on as well), similar to {@link appendEnvironment}.
+     * This always recurses parents.
+     */
+    overwrite(other: Environment | undefined, applyCds?: readonly ControlDependency[]): Environment;
+    /**
+     * Adds all writes of `other` to this environment (i.e., the operations of `other` *might* happen).
+     * This always recurses parents.
+     */
+    append(other: Environment | undefined): Environment;
+    remove(name: Identifier): this;
+    removeAll(names: readonly {
+        name: Identifier;
+    }[]): Environment;
+    toJSON(): Jsonified;
 }
 /**
  * An environment describes a ({@link IEnvironment#parent|scoped}) mapping of names to their definitions ({@link BuiltIns}).
@@ -55,7 +78,7 @@ export interface WorkingDirectoryReference {
  * but statically determining all attached environments is theoretically impossible --- consider attachments by user input).
  *
  * One important environment is the {@link BuiltIns|BuiltInEnvironment} which contains the default definitions for R's built-in functions and constants.
- * Please use {@link initializeCleanEnvironments} to initialize the environments (which includes the built-ins).
+ * This environment is created and provided by the {@link FlowrAnalyzerEnvironmentContext}.
  * During serialization, you may want to rely on the {@link builtInEnvJsonReplacer} to avoid the huge built-in environment.
  * @see {@link define} - to define a new {@link IdentifierDefinition|identifier definition} within an environment
  * @see {@link resolveByName} - to resolve an {@link Identifier|identifier/name} to its {@link IdentifierDefinition|definitions} within an environment
@@ -67,15 +90,12 @@ export interface WorkingDirectoryReference {
  */
 export interface REnvironmentInformation {
     /**  The currently active environment (the stack is represented by the currently active {@link IEnvironment#parent}). Environments are maintained within the dataflow graph. */
-    readonly current: IEnvironment;
+    readonly current: Environment;
     /** nesting level of the environment, will be `0` for the global/root environment */
     readonly level: number;
 }
-/**
- * Initialize a new {@link REnvironmentInformation|environment} with the built-ins.
- */
-export declare function initializeCleanEnvironments(memory?: BuiltInMemory, fullBuiltIns?: boolean): REnvironmentInformation;
 /**
  * Helps to serialize an environment, but replaces the built-in environment with a placeholder.
  */
 export declare function builtInEnvJsonReplacer(k: unknown, v: unknown): unknown;
+export {};

package/dataflow/environments/environment.js

@@ -1,61 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Environment = void 0;
-exports.makeReferenceMaybe = makeReferenceMaybe;
-exports.makeAllMaybe = makeAllMaybe;
 exports.isDefaultBuiltInEnvironment = isDefaultBuiltInEnvironment;
-exports.initializeCleanEnvironments = initializeCleanEnvironments;
 exports.builtInEnvJsonReplacer = builtInEnvJsonReplacer;
-const identifier_1 = require("./identifier");
-const resolve_by_name_1 = require("./resolve-by-name");
-const json_1 = require("../../util/json");
-const built_in_config_1 = require("./built-in-config");
-/**
- * Marks the reference as maybe (i.e., as controlled by a set of {@link IdentifierReference#controlDependencies|control dependencies}).
- */
-function makeReferenceMaybe(ref, graph, environments, includeDefs, defaultCd = undefined) {
-    if (includeDefs) {
-        const definitions = ref.name ? (0, resolve_by_name_1.resolveByName)(ref.name, environments, ref.type) : undefined;
-        for (const definition of definitions ?? []) {
-            if (definition.type !== identifier_1.ReferenceType.BuiltInFunction && definition.type !== identifier_1.ReferenceType.BuiltInConstant) {
-                if (definition.controlDependencies) {
-                    if (defaultCd && !definition.controlDependencies.find(c => c.id === defaultCd.id && c.when === defaultCd.when)) {
-                        definition.controlDependencies.push(defaultCd);
-                    }
-                }
-                else {
-                    definition.controlDependencies = defaultCd ? [defaultCd] : [];
-                }
-            }
-        }
-    }
-    const node = graph.getVertex(ref.nodeId, true);
-    if (node) {
-        if (node.cds) {
-            if (defaultCd && !node.cds.find(c => c.id === defaultCd.id && c.when === defaultCd.when)) {
-                node.cds.push(defaultCd);
-            }
-        }
-        else {
-            node.cds = defaultCd ? [defaultCd] : [];
-        }
-    }
-    if (ref.controlDependencies) {
-        if (defaultCd && !ref.controlDependencies.find(c => c.id === defaultCd.id && c.when === defaultCd.when)) {
-            return { ...ref, controlDependencies: (ref.controlDependencies ?? []).concat(defaultCd ? [defaultCd] : []) };
-        }
-    }
-    else {
-        return { ...ref, controlDependencies: ref.controlDependencies ?? (defaultCd ? [defaultCd] : []) };
-    }
-    return ref;
-}
 /**
- *
+ * Provides an environment structure similar to R.
+ * This allows the dataflow to hold current definition locations for variables, based on the current scope.
+ * @module
  */
-function makeAllMaybe(references, graph, environments, includeDefs, defaultCd = undefined) {
-    return references?.map(ref => makeReferenceMaybe(ref, graph, environments, includeDefs, defaultCd)) ?? [];
-}
+const json_1 = require("../../util/json");
+const assert_1 = require("../../util/assert");
+const info_1 = require("../info");
+const define_1 = require("./define");
+const append_1 = require("./append");
 /**
  * Please use this function only if you do not know the object type.
  * Otherwise, rely on {@link IEnvironment#builtInEnv}
@@ -69,6 +26,7 @@ class Environment {
     id;
     parent;
     memory;
+    cache;
     builtInEnv;
     constructor(parent, isBuiltInDefault = undefined) {
         this.id = isBuiltInDefault ? 0 : environmentIdCounter++;
@@ -79,19 +37,186 @@ class Environment {
             this.builtInEnv = isBuiltInDefault;
         }
     }
+    /**
+     * Create a deep clone of this environment.
+     * @param recurseParents     - Whether to also clone parent environments
+     */
+    clone(recurseParents) {
+        if (this.builtInEnv) {
+            return this; // do not clone the built-in environment
+        }
+        const parent = recurseParents ? this.parent.clone(recurseParents) : this.parent;
+        const clone = new Environment(parent, this.builtInEnv);
+        clone.memory = new Map(this.memory.entries()
+            .map(([k, v]) => [k,
+            v.map(s => ({
+                ...s,
+                controlDependencies: s.controlDependencies?.slice()
+            }))
+        ]));
+        return clone;
+    }
+    /**
+     * Define a new identifier definition within this environment.
+     * @param definition  - The definition to add.
+     * @param config      - The flowr configuration options.
+     */
+    define(definition, { solver: { pointerTracking } }) {
+        const { name } = definition;
+        const newEnvironment = this.clone(false);
+        // When there are defined indices, merge the definitions
+        if (definition.controlDependencies === undefined && !pointerTracking) {
+            newEnvironment.memory.set(name, [definition]);
+        }
+        else {
+            const existing = newEnvironment.memory.get(name);
+            const inGraphDefinition = definition;
+            if (pointerTracking &&
+                existing !== undefined &&
+                inGraphDefinition.controlDependencies === undefined) {
+                if (inGraphDefinition.indicesCollection !== undefined) {
+                    const defs = (0, define_1.mergeDefinitionsForPointer)(existing, inGraphDefinition);
+                    newEnvironment.memory.set(name, defs);
+                }
+                else if (existing?.flatMap(i => i.indicesCollection ?? []).length > 0) {
+                    // When indices couldn't be resolved, but indices where defined before, just add the definition
+                    existing.push(definition);
+                }
+            }
+            else if (existing === undefined || definition.controlDependencies === undefined) {
+                newEnvironment.memory.set(name, [definition]);
+            }
+            else {
+                existing.push(definition);
+            }
+        }
+        return newEnvironment;
+    }
+    defineSuper(definition) {
+        const { name } = definition;
+        const newEnvironment = this.clone(true);
+        let current = newEnvironment;
+        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.builtInEnv);
+        if (!found) {
+            (0, assert_1.guard)(last !== undefined, () => `Could not find global scope for ${name}`);
+            last.memory.set(name, [definition]);
+        }
+        return newEnvironment;
+    }
+    /**
+     * Assumes, that all definitions within other replace those within this environment (given the same name).
+     * <b>But</b> if all definitions within other are maybe, then they are appended to the current definitions (updating them to be `maybe` from now on as well), similar to {@link appendEnvironment}.
+     * This always recurses parents.
+     */
+    overwrite(other, applyCds) {
+        if (!other || this.builtInEnv) {
+            return this;
+        }
+        const map = new Map(this.memory);
+        for (const [key, values] of other.memory) {
+            const hasMaybe = applyCds === undefined ? values.length === 0 || values.some(v => v.controlDependencies !== undefined) : true;
+            if (hasMaybe) {
+                const old = map.get(key);
+                // we need to make a copy to avoid side effects for old reference in other environments
+                const updatedOld = old?.slice() ?? [];
+                for (const v of values) {
+                    const index = updatedOld.findIndex(o => o.nodeId === v.nodeId && o.definedAt === v.definedAt);
+                    if (index >= 0) {
+                        continue;
+                    }
+                    if (applyCds === undefined) {
+                        updatedOld.push(v);
+                    }
+                    else {
+                        updatedOld.push({
+                            ...v,
+                            controlDependencies: v.controlDependencies ? applyCds.concat(v.controlDependencies) : applyCds.slice()
+                        });
+                    }
+                }
+                map.set(key, updatedOld);
+            }
+            else {
+                map.set(key, values);
+            }
+        }
+        const out = new Environment(this.parent.overwrite(other.parent, applyCds));
+        out.memory = map;
+        return out;
+    }
+    /**
+     * Adds all writes of `other` to this environment (i.e., the operations of `other` *might* happen).
+     * This always recurses parents.
+     */
+    append(other) {
+        if (!other || this.builtInEnv) {
+            return this;
+        }
+        const map = new Map(this.memory);
+        for (const [key, value] of other.memory) {
+            const old = map.get(key);
+            if (old) {
+                map.set(key, (0, append_1.uniqueMergeValuesInDefinitions)(old, value));
+            }
+            else {
+                map.set(key, value);
+            }
+        }
+        const out = new Environment(this.parent.append(other.parent));
+        out.memory = map;
+        return out;
+    }
+    remove(name) {
+        if (this.builtInEnv) {
+            return this;
+        }
+        const definition = this.memory.get(name);
+        let cont = true;
+        if (definition !== undefined) {
+            this.memory.delete(name);
+            this.cache?.delete(name);
+            cont = !definition.every(d => (0, info_1.happensInEveryBranch)(d.controlDependencies));
+        }
+        if (cont) {
+            this.parent.remove(name);
+        }
+        return this;
+    }
+    removeAll(names) {
+        if (this.builtInEnv || names.length === 0) {
+            return this;
+        }
+        const newEnv = this.clone(true);
+        // we should optimize this later
+        for (const { name } of names) {
+            newEnv.remove(name);
+        }
+        return newEnv;
+    }
+    toJSON() {
+        return this.builtInEnv ? {
+            id: this.id,
+            parent: this.parent,
+            builtInEnv: this.builtInEnv,
+            memory: this.memory,
+        } : {
+            id: this.id,
+            parent: this.parent,
+            memory: this.memory,
+        };
+    }
 }
 exports.Environment = Environment;
-/**
- * Initialize a new {@link REnvironmentInformation|environment} with the built-ins.
- */
-function initializeCleanEnvironments(memory, fullBuiltIns = true) {
-    const builtInEnv = new Environment(undefined, true);
-    builtInEnv.memory = memory ?? (fullBuiltIns ? (0, built_in_config_1.getDefaultBuiltInDefinitions)().builtInMemory : (0, built_in_config_1.getDefaultBuiltInDefinitions)().emptyBuiltInMemory);
-    return {
-        current: new Environment(builtInEnv),
-        level: 0
-    };
-}
 /**
  * Helps to serialize an environment, but replaces the built-in environment with a placeholder.
  */

package/dataflow/environments/overwrite.d.ts

@@ -1,9 +1,5 @@
-import { type IEnvironment, type REnvironmentInformation } from './environment';
+import { type REnvironmentInformation } from './environment';
 import type { ControlDependency } from '../info';
-/**
- *
- */
-export declare function overwriteIEnvironmentWith(base: IEnvironment | undefined, next: IEnvironment | undefined, includeParent?: boolean, applyCds?: readonly ControlDependency[]): IEnvironment;
 export declare function overwriteEnvironment(base: REnvironmentInformation, next: REnvironmentInformation | undefined, applyCds?: readonly ControlDependency[]): REnvironmentInformation;
 export declare function overwriteEnvironment(base: REnvironmentInformation | undefined, next: REnvironmentInformation, applyCds?: readonly ControlDependency[]): REnvironmentInformation;
 export declare function overwriteEnvironment(base: undefined, next: undefined, applyCds?: readonly ControlDependency[]): undefined;

package/dataflow/environments/overwrite.js

@@ -1,70 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.overwriteIEnvironmentWith = overwriteIEnvironmentWith;
 exports.overwriteEnvironment = overwriteEnvironment;
 const assert_1 = require("../../util/assert");
-const environment_1 = require("./environment");
-const log_1 = require("../../util/log");
-function anyIsMaybeOrEmpty(values) {
-    if (values.length === 0) {
-        return true;
-    }
-    for (const val of values) {
-        if (val.controlDependencies !== undefined) {
-            return true;
-        }
-    }
-    return false;
-}
-/**
- *
- */
-function overwriteIEnvironmentWith(base, next, includeParent = true, applyCds) {
-    (0, assert_1.guard)(base !== undefined && next !== undefined, 'can not overwrite environments with undefined');
-    const map = new Map(base.memory);
-    for (const [key, values] of next.memory) {
-        if (values.length > 1_000_000) {
-            log_1.log.warn(`Overwriting environment with ${values.length} definitions for ${key}`);
-        }
-        const hasMaybe = applyCds !== undefined ? true : anyIsMaybeOrEmpty(values);
-        if (hasMaybe) {
-            const old = map.get(key);
-            // we need to make a copy to avoid side effects for old reference in other environments
-            const updatedOld = [...old ?? []];
-            for (const v of values) {
-                const index = updatedOld.findIndex(o => o.nodeId === v.nodeId && o.definedAt === v.definedAt);
-                if (index < 0) {
-                    if (applyCds !== undefined) {
-                        updatedOld.push({
-                            ...v,
-                            controlDependencies: applyCds.concat(v.controlDependencies ?? [])
-                        });
-                    }
-                    else {
-                        updatedOld.push(v);
-                    }
-                }
-            }
-            map.set(key, updatedOld);
-        }
-        else {
-            map.set(key, values);
-        }
-    }
-    let parent;
-    if (includeParent) {
-        parent = base.parent.builtInEnv ? base.parent : overwriteIEnvironmentWith(base.parent, next.parent, includeParent, applyCds);
-    }
-    else {
-        parent = base.parent;
-    }
-    const out = new environment_1.Environment(parent);
-    out.memory = map;
-    return out;
-}
 /**
  * Assumes, that all definitions within next replace those within base (given the same name).
  * <b>But</b> if all definitions within next are maybe, then they are appended to the base definitions (updating them to be `maybe` from now on as well), similar to {@link appendEnvironment}.
+ * @see {@link Environment.overwrite} - for details on how definitions are handled.
  */
 function overwriteEnvironment(base, next, applyCds) {
     if (base === undefined) {
@@ -75,7 +16,7 @@ function overwriteEnvironment(base, next, applyCds) {
     }
     (0, assert_1.guard)(next.level === base.level, `cannot overwrite environments with differently nested local scopes, base ${base.level} vs. next ${next.level}. This should not happen.`);
     return {
-        current: overwriteIEnvironmentWith(base.current, next.current, true, applyCds),
+        current: base.current.overwrite(next.current, applyCds),
         level: base.level
     };
 }

package/dataflow/environments/reference-to-maybe.d.ts

@@ -0,0 +1,13 @@
+import type { IdentifierReference } from './identifier';
+import type { DataflowGraph } from '../graph/graph';
+import type { ControlDependency } from '../info';
+import type { REnvironmentInformation } from './environment';
+/**
+ * Marks the reference as maybe (i.e., as controlled by a set of {@link IdentifierReference#controlDependencies|control dependencies}).
+ */
+export declare function makeReferenceMaybe(ref: IdentifierReference, graph: DataflowGraph, environments: REnvironmentInformation, includeDefs: boolean, defaultCd?: ControlDependency | undefined): IdentifierReference;
+/**
+ * Marks all references as maybe (i.e., as controlled by a set of {@link IdentifierReference#controlDependencies|control dependencies}).
+ * @see {@link makeReferenceMaybe}
+ */
+export declare function makeAllMaybe(references: readonly IdentifierReference[] | undefined, graph: DataflowGraph, environments: REnvironmentInformation, includeDefs: boolean, defaultCd?: ControlDependency | undefined): IdentifierReference[];