@eagleoutice/flowr 2.6.3 → 2.7.0

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.js

@@ -2,53 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.overwriteEnvironment = overwriteEnvironment;
 const assert_1 = require("../../util/assert");
-const environment_1 = require("./environment");
-function anyIsMaybeOrEmpty(values) {
-    return values.length === 0 || values.some(v => v.controlDependencies !== undefined);
-}
-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) {
-        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?.slice() ?? [];
-            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: v.controlDependencies ? applyCds.concat(v.controlDependencies) : applyCds.slice()
-                        });
-                    }
-                    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) {
@@ -59,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[];

package/dataflow/environments/reference-to-maybe.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeReferenceMaybe = makeReferenceMaybe;
+exports.makeAllMaybe = makeAllMaybe;
+const identifier_1 = require("./identifier");
+const resolve_by_name_1 = require("./resolve-by-name");
+/**
+ * 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;
+}
+/**
+ * Marks all references as maybe (i.e., as controlled by a set of {@link IdentifierReference#controlDependencies|control dependencies}).
+ * @see {@link makeReferenceMaybe}
+ */
+function makeAllMaybe(references, graph, environments, includeDefs, defaultCd = undefined) {
+    return references?.map(ref => makeReferenceMaybe(ref, graph, environments, includeDefs, defaultCd)) ?? [];
+}
+//# sourceMappingURL=reference-to-maybe.js.map

package/dataflow/environments/resolve-by-name.d.ts

@@ -3,13 +3,18 @@ import { Ternary } from '../../util/logic';
 import { type Identifier, type IdentifierDefinition, ReferenceType } from './identifier';
 /**
  * Resolves a given identifier name to a list of its possible definition location using R scoping and resolving rules.
+ * If the type you want to reference is unknown, please use {@link resolveByNameAnyType} instead.
  * @param name               - The name of the identifier to resolve
  * @param environment        - The current environment used for name resolution
  * @param target             - The target (meta) type of the identifier to resolve
  * @returns A list of possible identifier definitions (one if the definition location is exactly and always known), or `undefined`
  *          if the identifier is undefined in the current scope/with the current environment information.
  */
-export declare function resolveByName(name: Identifier, environment: REnvironmentInformation, target?: ReferenceType): IdentifierDefinition[] | undefined;
+export declare function resolveByName(name: Identifier, environment: REnvironmentInformation, target: ReferenceType): IdentifierDefinition[] | undefined;
+/**
+ * The more performant version of {@link resolveByName} when the target type is unknown.
+ */
+export declare function resolveByNameAnyType(name: Identifier, environment: REnvironmentInformation): IdentifierDefinition[] | undefined;
 /**
  *
  */

package/dataflow/environments/resolve-by-name.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveByName = resolveByName;
+exports.resolveByNameAnyType = resolveByNameAnyType;
 exports.resolvesToBuiltInConstant = resolvesToBuiltInConstant;
 const logic_1 = require("../../util/logic");
 const identifier_1 = require("./identifier");
@@ -22,26 +23,34 @@ const TargetTypePredicate = {
 };
 /**
  * Resolves a given identifier name to a list of its possible definition location using R scoping and resolving rules.
+ * If the type you want to reference is unknown, please use {@link resolveByNameAnyType} instead.
  * @param name               - The name of the identifier to resolve
  * @param environment        - The current environment used for name resolution
  * @param target             - The target (meta) type of the identifier to resolve
  * @returns A list of possible identifier definitions (one if the definition location is exactly and always known), or `undefined`
  *          if the identifier is undefined in the current scope/with the current environment information.
  */
-function resolveByName(name, environment, target = identifier_1.ReferenceType.Unknown) {
+function resolveByName(name, environment, target) {
+    if (target === identifier_1.ReferenceType.Unknown) {
+        return resolveByNameAnyType(name, environment);
+    }
     let current = environment.current;
     let definitions = undefined;
     const wantedType = TargetTypePredicate[target];
     do {
         const definition = current.memory.get(name);
         if (definition !== undefined) {
-            const filtered = target === identifier_1.ReferenceType.Unknown ? definition : definition.filter(wantedType);
+            const filtered = definition.filter(wantedType);
             if (filtered.length === definition.length && definition.every(d => (0, info_1.happensInEveryBranch)(d.controlDependencies))) {
                 return definition;
             }
             else if (filtered.length > 0) {
-                definitions ??= [];
-                definitions = definitions.concat(filtered);
+                if (definitions) {
+                    definitions = definitions.concat(filtered);
+                }
+                else {
+                    definitions = filtered;
+                }
             }
         }
         current = current.parent;
@@ -54,6 +63,49 @@ function resolveByName(name, environment, target = identifier_1.ReferenceType.Un
         return builtIns;
     }
 }
+/**
+ * The more performant version of {@link resolveByName} when the target type is unknown.
+ */
+function resolveByNameAnyType(name, environment) {
+    let current = environment.current;
+    const g = current.cache?.get(name);
+    if (g !== undefined) {
+        return g;
+    }
+    let definitions = undefined;
+    do {
+        const definition = current.memory.get(name);
+        if (definition) {
+            if (definition.every(d => (0, info_1.happensInEveryBranch)(d.controlDependencies))) {
+                environment.current.cache ??= new Map();
+                environment.current.cache?.set(name, definition);
+                return definition;
+            }
+            else if (definition.length > 0) {
+                if (definitions) {
+                    definitions = definitions.concat(definition);
+                }
+                else {
+                    definitions = definition;
+                }
+            }
+        }
+        current = current.parent;
+    } while (!current.builtInEnv);
+    const builtIns = current.memory.get(name);
+    let ret;
+    if (definitions) {
+        ret = builtIns === undefined ? definitions : definitions.concat(builtIns);
+    }
+    else {
+        ret = builtIns;
+    }
+    if (ret) {
+        environment.current.cache ??= new Map();
+        environment.current.cache?.set(name, ret);
+    }
+    return ret;
+}
 /**
  *
  */

package/dataflow/environments/scoping.d.ts

@@ -3,9 +3,9 @@ import { type REnvironmentInformation } from './environment';
  * Add a new local environment scope to the stack, returns the modified variant - sharing the original environments in the stack (no deep-clone)
  * @see {@link popLocalEnvironment} - to remove the local scope again
  */
-export declare function pushLocalEnvironment(base: REnvironmentInformation): REnvironmentInformation;
+export declare function pushLocalEnvironment({ level, current }: REnvironmentInformation): REnvironmentInformation;
 /**
  * Remove the top local environment scope from the stack, returns the modified variant - sharing the original environments in the stack (no deep-clone)
  * @see {@link pushLocalEnvironment} - to add a local scope
  */
-export declare function popLocalEnvironment(base: REnvironmentInformation): REnvironmentInformation;
+export declare function popLocalEnvironment({ current, level }: REnvironmentInformation): REnvironmentInformation;