@eagleoutice/flowr 2.4.0 → 2.4.1

package/dataflow/environments/define.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeDefinitions = mergeDefinitions;
 exports.define = define;
 const assert_1 = require("../../util/assert");
-const environment_1 = require("./environment");
 const clone_1 = require("./clone");
 const vertex_1 = require("../graph/vertex");
 function defInEnv(newEnvironments, name, definition, config) {
@@ -138,7 +137,7 @@ function define(definition, superAssign, environment, config) {
             }
             last = current;
             current = current.parent;
-        } while (current.id !== environment_1.BuiltInEnvironment.id);
+        } while (!current.builtInEnv);
         if (!found) {
             (0, assert_1.guard)(last !== undefined, () => `Could not find global scope for ${name}`);
             last.memory.set(name, [definition]);

package/dataflow/environments/diff.js

@@ -7,7 +7,6 @@ const diff_1 = require("../../util/diff");
 const environment_1 = require("./environment");
 const json_1 = require("../../util/json");
 const info_1 = require("../info");
-const built_in_1 = require("./built-in");
 function diffIdentifierReferences(a, b, info) {
     if (a === undefined || b === undefined) {
         if (a !== b) {
@@ -59,8 +58,7 @@ function diffEnvironment(a, b, info, depth) {
         }
         return;
     }
-    if ((a.memory === built_in_1.BuiltInMemory || a.memory === built_in_1.EmptyBuiltInMemory) &&
-        (b.memory === built_in_1.BuiltInMemory || b.memory === built_in_1.EmptyBuiltInMemory)) {
+    if (a.builtInEnv && b.builtInEnv) {
         return;
     }
     if (a.memory.size !== b.memory.size) {

package/dataflow/environments/environment.d.ts

@@ -4,15 +4,15 @@
  *
  * @module
  */
-import type { Identifier, IdentifierDefinition, IdentifierReference } from './identifier';
+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[];
-export type EnvironmentMemory = Map<Identifier, IdentifierDefinition[]>;
 /** 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 */
@@ -20,21 +20,31 @@ export interface IEnvironment {
     /** Lexical parent of the environment, if any (can be manipulated by R code) */
     parent: IEnvironment;
     /** Maps to exactly one definition of an identifier if the source is known, otherwise to a list of all possible definitions */
-    memory: EnvironmentMemory;
+    memory: BuiltInMemory;
+    /**
+     * Is this a built-in environment that is not allowed to change? Please use this carefully and only for the top-most envs!
+     */
+    builtInEnv?: true | undefined;
 }
+/**
+ * Please use this function only if you do not know the object type.
+ * Otherwise, rely on {@link IEnvironment#builtInEnv}
+ */
+export declare function isDefaultBuiltInEnvironment(obj: unknown): boolean;
 /** @see REnvironmentInformation */
 export declare class Environment implements IEnvironment {
     readonly id: number;
     parent: IEnvironment;
-    memory: Map<Identifier, IdentifierDefinition[]>;
-    constructor(parent: IEnvironment);
+    memory: BuiltInMemory;
+    builtInEnv?: true;
+    constructor(parent: IEnvironment, isBuiltInDefault?: true | undefined);
 }
 export interface WorkingDirectoryReference {
     readonly path: string;
     readonly controlDependencies: ControlDependency[] | undefined;
 }
 /**
- * An environment describes a ({@link IEnvironment#parent|scoped}) mapping of names to their definitions ({@link EnvironmentMemory}).
+ * An environment describes a ({@link IEnvironment#parent|scoped}) mapping of names to their definitions ({@link BuiltIns}).
  *
  * First, yes, R stores its environments differently, potentially even with another differentiation between
  * the `baseenv`, the `emptyenv`, and other default environments (see https://adv-r.hadley.nz/environments.html).
@@ -42,7 +52,7 @@ export interface WorkingDirectoryReference {
  * and sometimes know less (to be honest, we do not want that,
  * but statically determining all attached environments is theoretically impossible --- consider attachments by user input).
  *
- * One important environment is the {@link BuiltInEnvironment} which contains the default definitions for R's built-in functions and constants.
+ * 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).
  * During serialization, you may want to rely on the {@link builtInEnvJsonReplacer} to avoid the huge built-in environment.
  *
@@ -61,26 +71,10 @@ export interface REnvironmentInformation {
     /** nesting level of the environment, will be `0` for the global/root environment */
     readonly level: number;
 }
-/**
- * The built-in {@link REnvironmentInformation|environment} is the root of all environments.
- *
- * For its default content (when not overwritten by a flowR config),
- * see the {@link DefaultBuiltinConfig}.
- */
-export declare const BuiltInEnvironment: Environment;
-/**
- * The twin of the {@link BuiltInEnvironment} but with less built ins defined for
- * cases in which we want some commonly overwritten variables to remain open.
- * If you do not know if you need the empty environment, you do not need the empty environment (right now).
- *
- * @see {@link BuiltInEnvironment}
- */
-export declare const EmptyBuiltInEnvironment: IEnvironment;
 /**
  * Initialize a new {@link REnvironmentInformation|environment} with the built-ins.
- * See {@link EmptyBuiltInEnvironment} for the case `fullBuiltIns = false`.
  */
-export declare function initializeCleanEnvironments(fullBuiltIns?: boolean): REnvironmentInformation;
+export declare function initializeCleanEnvironments(memory?: BuiltInMemory, fullBuiltIns?: boolean): REnvironmentInformation;
 /**
  * Helps to serialize an environment, but replaces the built-in environment with a placeholder.
  */

package/dataflow/environments/environment.js

@@ -1,19 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EmptyBuiltInEnvironment = exports.BuiltInEnvironment = exports.Environment = void 0;
+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 built_in_1 = require("./built-in");
 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) {
-    const node = graph.get(ref.nodeId, true);
     if (includeDefs) {
         const definitions = ref.name ? (0, resolve_by_name_1.resolveByName)(ref.name, environments, ref.type) : undefined;
         for (const definition of definitions ?? []) {
@@ -27,6 +27,7 @@ function makeReferenceMaybe(ref, graph, environments, includeDefs, defaultCd = u
             }
         }
     }
+    const node = graph.get(ref.nodeId, true);
     if (node) {
         const [fst] = node;
         if (fst.cds && defaultCd && !fst.cds.includes(defaultCd)) {
@@ -44,49 +45,39 @@ function makeAllMaybe(references, graph, environments, includeDefs, defaultCd =
     }
     return references.map(ref => makeReferenceMaybe(ref, graph, environments, includeDefs, defaultCd));
 }
-let environmentIdCounter = 0;
+/**
+ * Please use this function only if you do not know the object type.
+ * Otherwise, rely on {@link IEnvironment#builtInEnv}
+ */
+function isDefaultBuiltInEnvironment(obj) {
+    return typeof obj === 'object' && obj !== null && (obj.builtInEnv === true);
+}
+let environmentIdCounter = 1; // Zero is reserved for built-in environment
 /** @see REnvironmentInformation */
 class Environment {
-    id = environmentIdCounter++;
+    id;
     parent;
     memory;
-    constructor(parent) {
+    builtInEnv;
+    constructor(parent, isBuiltInDefault = undefined) {
+        this.id = isBuiltInDefault ? 0 : environmentIdCounter++;
         this.parent = parent;
         this.memory = new Map();
+        // do not store if not needed!
+        if (isBuiltInDefault) {
+            this.builtInEnv = isBuiltInDefault;
+        }
     }
 }
 exports.Environment = Environment;
-/**
- * The built-in {@link REnvironmentInformation|environment} is the root of all environments.
- *
- * For its default content (when not overwritten by a flowR config),
- * see the {@link DefaultBuiltinConfig}.
- */
-exports.BuiltInEnvironment = new Environment(undefined);
-exports.BuiltInEnvironment.memory = undefined;
-/**
- * The twin of the {@link BuiltInEnvironment} but with less built ins defined for
- * cases in which we want some commonly overwritten variables to remain open.
- * If you do not know if you need the empty environment, you do not need the empty environment (right now).
- *
- * @see {@link BuiltInEnvironment}
- */
-exports.EmptyBuiltInEnvironment = {
-    id: exports.BuiltInEnvironment.id,
-    memory: undefined,
-    parent: undefined
-};
 /**
  * Initialize a new {@link REnvironmentInformation|environment} with the built-ins.
- * See {@link EmptyBuiltInEnvironment} for the case `fullBuiltIns = false`.
  */
-function initializeCleanEnvironments(fullBuiltIns = true) {
-    if (exports.BuiltInEnvironment.memory === undefined) {
-        exports.BuiltInEnvironment.memory = built_in_1.BuiltInMemory;
-        exports.EmptyBuiltInEnvironment.memory = built_in_1.EmptyBuiltInMemory;
-    }
+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(fullBuiltIns ? exports.BuiltInEnvironment : exports.EmptyBuiltInEnvironment),
+        current: new Environment(builtInEnv),
         level: 0
     };
 }
@@ -94,12 +85,9 @@ function initializeCleanEnvironments(fullBuiltIns = true) {
  * Helps to serialize an environment, but replaces the built-in environment with a placeholder.
  */
 function builtInEnvJsonReplacer(k, v) {
-    if (v === exports.BuiltInEnvironment) {
+    if (isDefaultBuiltInEnvironment(v)) {
         return '<BuiltInEnvironment>';
     }
-    else if (v === exports.EmptyBuiltInEnvironment) {
-        return '<EmptyBuiltInEnvironment>';
-    }
     else {
         return (0, json_1.jsonReplacer)(k, v);
     }

package/dataflow/environments/overwrite.d.ts

@@ -1,4 +1,4 @@
-import type { REnvironmentInformation, IEnvironment } from './environment';
+import type { IEnvironment, 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;

package/dataflow/environments/overwrite.js

@@ -50,7 +50,7 @@ function overwriteIEnvironmentWith(base, next, includeParent = true, applyCds) {
     }
     let parent;
     if (includeParent) {
-        parent = base.parent.id === environment_1.BuiltInEnvironment.id ? environment_1.BuiltInEnvironment : overwriteIEnvironmentWith(base.parent, next.parent, includeParent, applyCds);
+        parent = base.parent.builtInEnv ? base.parent : overwriteIEnvironmentWith(base.parent, next.parent, includeParent, applyCds);
     }
     else {
         parent = base.parent;

package/dataflow/environments/remove.d.ts

@@ -1,10 +1,10 @@
-import type { REnvironmentInformation } from './environment';
+import type { IEnvironment, REnvironmentInformation } from './environment';
 import type { Identifier } from './identifier';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 /**
  * Removes all definitions of a given name from the environment.
  */
-export declare function remove(name: Identifier, environment: REnvironmentInformation): REnvironmentInformation;
+export declare function remove(name: Identifier, environment: REnvironmentInformation, defaultEnvironment: IEnvironment): REnvironmentInformation;
 /** Creates a copy of the original environment but without the definitions of the given ids */
 export declare function removeAll(definitions: readonly {
     nodeId: NodeId;

package/dataflow/environments/remove.js

@@ -2,13 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.remove = remove;
 exports.removeAll = removeAll;
-const environment_1 = require("./environment");
 const info_1 = require("../info");
 const clone_1 = require("./clone");
 /**
  * Removes all definitions of a given name from the environment.
  */
-function remove(name, environment) {
+function remove(name, environment, defaultEnvironment) {
     let current = environment.current;
     do {
         const definition = current.memory.get(name);
@@ -19,7 +18,7 @@ function remove(name, environment) {
             }
         }
         current = current.parent;
-    } while (current.id !== environment_1.BuiltInEnvironment.id);
+    } while (current.id !== defaultEnvironment.id);
     // we never remove built ins
     return environment;
 }
@@ -46,7 +45,7 @@ function removeAll(definitions, environment) {
             }
         }
         current = current.parent;
-    } while (current.id !== environment_1.BuiltInEnvironment.id);
+    } while (!current.builtInEnv);
     // we never remove built ins so we can stop one early
     return environment;
 }

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

@@ -5,9 +5,9 @@ import { ReferenceType } from './identifier';
 /**
  * Resolves a given identifier name to a list of its possible definition location using R scoping and resolving rules.
  *
- * @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
+ * @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.

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

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveByName = resolveByName;
 exports.resolvesToBuiltInConstant = resolvesToBuiltInConstant;
-const environment_1 = require("./environment");
 const logic_1 = require("../../util/logic");
 const identifier_1 = require("./identifier");
 const info_1 = require("../info");
@@ -24,9 +23,9 @@ const TargetTypePredicate = {
 /**
  * Resolves a given identifier name to a list of its possible definition location using R scoping and resolving rules.
  *
- * @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
+ * @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.
@@ -48,7 +47,7 @@ function resolveByName(name, environment, target = identifier_1.ReferenceType.Un
             }
         }
         current = current.parent;
-    } while (current.id !== environment_1.BuiltInEnvironment.id);
+    } while (!current.builtInEnv);
     const builtIns = current.memory.get(name);
     if (definitions) {
         return builtIns === undefined ? definitions : definitions.concat(builtIns);

package/dataflow/eval/resolve/alias-tracking.d.ts

@@ -27,9 +27,9 @@ export interface ResolveInfo {
  * us later, in the {@link trackAliasInEnvironments} function, to get all the
  * aliases of an identifier.
  *
- * @param sourceIds    - node ids to get the definitions for
- * @param dataflow     - dataflow graph
- * @param environment  - environment
+ * @param sourceIds          - node ids to get the definitions for
+ * @param dataflow           - dataflow graph
+ * @param environment        - environment
  * @returns node id of alias
  */
 export declare function getAliases(sourceIds: readonly NodeId[], dataflow: DataflowGraph, environment: REnvironmentInformation): NodeId[] | undefined;
@@ -46,12 +46,12 @@ export declare function getAliases(sourceIds: readonly NodeId[], dataflow: Dataf
  * to resolve values. For e.g. in the Dependency Query it is used to resolve calls
  * like `lapply(c("a", "b", "c"), library, character.only = TRUE)`
  *
- * @param id          - The node id or node to resolve
- * @param environment - The current environment used for name resolution
- * @param graph       - The graph to resolve in
- * @param idMap       - The id map to resolve the node if given as an id
- * @param full        - Whether to track aliases on resolve
- * @param resolve     - Variable resolve mode
+ * @param id                 - The node id or node to resolve
+ * @param environment        - The current environment used for name resolution
+ * @param graph              - The graph to resolve in
+ * @param idMap              - The id map to resolve the node if given as an id
+ * @param full               - Whether to track aliases on resolve
+ * @param resolve            - Variable resolve mode
  */
 export declare function resolveIdToValue(id: NodeId | RNodeWithParent | undefined, { environment, graph, idMap, full, resolve }: ResolveInfo): ResolveResult;
 /**
@@ -64,7 +64,7 @@ export declare function resolveIdToValue(id: NodeId | RNodeWithParent | undefine
  * @param resolve    - Variable resolve mode
  * @param identifier - Identifier to resolve
  * @param use        - Environment to use
- * @param graph      - Dataflow graph
+ * @param graph      - dataflow graph
  * @param idMap      - id map of Dataflow graph
  * @returns Value of Identifier or Top
  */
@@ -85,8 +85,8 @@ export declare function trackAliasesInGraph(id: NodeId, graph: DataflowGraph, id
  *
  * Resolve an Identifier to a constant, if the identifier is a constant
  *
- * @param name        - Identifier to resolve
- * @param environment - Environment to use
+ * @param name               - Identifier to resolve
+ * @param environment        - Environment to use
  * @returns Value of Constant or Top
  */
 export declare function resolveToConstants(name: Identifier | undefined, environment: REnvironmentInformation): ResolveResult;

package/dataflow/eval/resolve/alias-tracking.js

@@ -78,9 +78,9 @@ function getUseAlias(sourceId, dataflow, environment) {
  * us later, in the {@link trackAliasInEnvironments} function, to get all the
  * aliases of an identifier.
  *
- * @param sourceIds    - node ids to get the definitions for
- * @param dataflow     - dataflow graph
- * @param environment  - environment
+ * @param sourceIds          - node ids to get the definitions for
+ * @param dataflow           - dataflow graph
+ * @param environment        - environment
  * @returns node id of alias
  */
 function getAliases(sourceIds, dataflow, environment) {
@@ -110,12 +110,12 @@ function getAliases(sourceIds, dataflow, environment) {
  * to resolve values. For e.g. in the Dependency Query it is used to resolve calls
  * like `lapply(c("a", "b", "c"), library, character.only = TRUE)`
  *
- * @param id          - The node id or node to resolve
- * @param environment - The current environment used for name resolution
- * @param graph       - The graph to resolve in
- * @param idMap       - The id map to resolve the node if given as an id
- * @param full        - Whether to track aliases on resolve
- * @param resolve     - Variable resolve mode
+ * @param id                 - The node id or node to resolve
+ * @param environment        - The current environment used for name resolution
+ * @param graph              - The graph to resolve in
+ * @param idMap              - The id map to resolve the node if given as an id
+ * @param full               - Whether to track aliases on resolve
+ * @param resolve            - Variable resolve mode
  */
 function resolveIdToValue(id, { environment, graph, idMap, full = true, resolve }) {
     if (id === undefined) {
@@ -160,7 +160,7 @@ function resolveIdToValue(id, { environment, graph, idMap, full = true, resolve
  * @param resolve    - Variable resolve mode
  * @param identifier - Identifier to resolve
  * @param use        - Environment to use
- * @param graph      - Dataflow graph
+ * @param graph      - dataflow graph
  * @param idMap      - id map of Dataflow graph
  * @returns Value of Identifier or Top
  */
@@ -333,8 +333,8 @@ function trackAliasesInGraph(id, graph, idMap) {
  *
  * Resolve an Identifier to a constant, if the identifier is a constant
  *
- * @param name        - Identifier to resolve
- * @param environment - Environment to use
+ * @param name               - Identifier to resolve
+ * @param environment        - Environment to use
  * @returns Value of Constant or Top
  */
 function resolveToConstants(name, environment) {

package/dataflow/eval/resolve/resolve.js

@@ -59,7 +59,7 @@ function resolveNode(resolve, a, env, graph, map) {
         else {
             return r_value_2.Top;
         }
-        if (Object.prototype.hasOwnProperty.call(built_in_1.BuiltInEvalHandlerMapper, builtInName)) {
+        if (Object.hasOwn(built_in_1.BuiltInEvalHandlerMapper, builtInName)) {
             const handler = built_in_1.BuiltInEvalHandlerMapper[builtInName];
             return handler(resolve, a, env, graph, map);
         }

package/dataflow/extractor.js

@@ -20,6 +20,7 @@ const extract_cfg_1 = require("../control-flow/extract-cfg");
 const edge_1 = require("./graph/edge");
 const identify_link_to_last_call_relation_1 = require("../queries/catalog/call-context-query/identify-link-to-last-call-relation");
 const built_in_function_definition_1 = require("./internal/process/functions/call/built-in/built-in-function-definition");
+const built_in_config_1 = require("./environments/built-in-config");
 /**
  * The best friend of {@link produceDataFlowGraph} and {@link processDataflowFor}.
  * Maps every {@link RType} in the normalized AST to a processor.
@@ -89,10 +90,14 @@ function produceDataFlowGraph(parser, request, completeAst, config) {
     else {
         firstRequest = request;
     }
+    const builtInsConfig = config.semantics.environment.overwriteBuiltIns;
+    const builtIns = (0, built_in_config_1.getBuiltInDefinitions)(builtInsConfig.definitions, builtInsConfig.loadDefaults);
+    const env = (0, environment_1.initializeCleanEnvironments)(builtIns.builtInMemory);
     const dfData = {
         parser,
         completeAst,
-        environment: (0, environment_1.initializeCleanEnvironments)(),
+        environment: env,
+        builtInEnvironment: env.current.parent,
         processors: exports.processors,
         currentRequest: firstRequest,
         controlDependencies: undefined,

package/dataflow/graph/dataflowgraph-builder.d.ts

@@ -2,7 +2,7 @@ import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-i
 import type { AstIdMap } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { DataflowFunctionFlowInformation, FunctionArgument } from './graph';
 import { DataflowGraph } from './graph';
-import type { REnvironmentInformation } from '../environments/environment';
+import type { IEnvironment, REnvironmentInformation } from '../environments/environment';
 import type { DataflowGraphVertexAstLink, DataflowGraphVertexUse, FunctionOriginInformation } from './vertex';
 import type { ControlDependency } from '../info';
 import type { LinkTo } from '../../queries/catalog/call-context-query/call-context-query-format';
@@ -29,6 +29,7 @@ export declare class DataflowGraphBuilder extends DataflowGraph {
      */
     defineFunction(id: NodeId, exitPoints: readonly NodeId[], subflow: DataflowFunctionFlowInformation, info?: {
         environment?: REnvironmentInformation;
+        builtInEnvironment?: IEnvironment;
         controlDependencies?: ControlDependency[];
     }, asRoot?: boolean): this;
     /**
@@ -46,6 +47,7 @@ export declare class DataflowGraphBuilder extends DataflowGraph {
         reads?: readonly NodeId[];
         onlyBuiltIn?: boolean;
         environment?: REnvironmentInformation;
+        builtInEnvironment?: IEnvironment;
         controlDependencies?: ControlDependency[];
         origin?: FunctionOriginInformation[];
         link?: DataflowGraphVertexAstLink;

package/dataflow/graph/graph.d.ts

@@ -160,7 +160,7 @@ export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = Data
      *
      * @see #edges
      */
-    vertices(includeDefinedFunctions: boolean): IterableIterator<[NodeId, Vertex]>;
+    vertices(includeDefinedFunctions: boolean): MapIterator<[NodeId, Vertex]>;
     /**
      * @returns the ids of all edges in the graph together with their edge information
      *
@@ -231,5 +231,6 @@ export interface IEnvironmentJson {
     readonly id: number;
     parent: IEnvironmentJson;
     memory: Record<Identifier, IdentifierDefinition[]>;
+    builtInEnv: true | undefined;
 }
 export {};

package/dataflow/graph/graph.js

@@ -394,11 +394,15 @@ function envFromJson(json) {
     for (const [key, value] of Object.entries(json.memory)) {
         memory.set(key, value);
     }
-    return {
+    const obj = {
         id: json.id,
         parent: parent,
         memory
     };
+    if (json.builtInEnv) {
+        obj.builtInEnv = true;
+    }
+    return obj;
 }
 function renvFromJson(json) {
     const current = envFromJson(json.current);

package/dataflow/info.d.ts

@@ -109,7 +109,7 @@ export interface DataflowInformation extends DataflowCfgInformation {
  *
  * @see {@link DataflowInformation}
  */
-export declare function initializeCleanDataflowInformation<T>(entryPoint: NodeId, data: Pick<DataflowProcessorInformation<T>, 'environment' | 'completeAst'>): DataflowInformation;
+export declare function initializeCleanDataflowInformation<T>(entryPoint: NodeId, data: Pick<DataflowProcessorInformation<T>, 'environment' | 'builtInEnvironment' | 'completeAst'>): DataflowInformation;
 /**
  * Checks whether the given control dependencies are exhaustive (i.e. if for every control dependency on a boolean,
  * the list contains a dependency on the `true` and on the `false` case).

package/dataflow/internal/linker.js

@@ -25,7 +25,7 @@ const built_in_1 = require("../environments/built-in");
 const prefix_1 = require("../../util/prefix");
 function findNonLocalReads(graph, ignore) {
     const ignores = new Set(ignore.map(i => i.nodeId));
-    const ids = new Set([...graph.vertices(true)]
+    const ids = new Set(graph.vertices(true)
         .filter(([_, info]) => info.tag === vertex_1.VertexType.Use || info.tag === vertex_1.VertexType.FunctionCall)
         .map(([id, _]) => id));
     /* find all variable use ids which do not link to a given id */
@@ -74,27 +74,27 @@ function produceNameSharedIdMap(references) {
 }
 function linkArgumentsOnCall(args, params, graph) {
     const nameArgMap = new Map(args.filter(graph_1.isNamedArgument).map(a => [a.name, a]));
-    const nameParamMap = new Map(params.filter(p => p !== undefined && p.name !== undefined && p.name.content !== undefined).map(p => [p.name.content, p]));
+    const nameParamMap = new Map(params.filter(p => p?.name?.content !== undefined).map(p => [p.name.content, p]));
     const specialDotParameter = params.find(p => p.special);
     // all parameters matched by name
     const matchedParameters = new Set();
     // first map names
     for (const [name, arg] of nameArgMap) {
-        const pmatchName = (0, prefix_1.findByPrefixIfUnique)(name, [...nameParamMap.keys()]) ?? name;
+        const pmatchName = (0, prefix_1.findByPrefixIfUnique)(name, nameParamMap.keys()) ?? name;
         const param = nameParamMap.get(pmatchName);
-        if (param !== undefined && param.name) {
+        if (param?.name) {
             logger_1.dataflowLogger.trace(`mapping named argument "${name}" to parameter "${param.name.content}"`);
             graph.addEdge(arg.nodeId, param.name.info.id, edge_1.EdgeType.DefinesOnCall);
             graph.addEdge(param.name.info.id, arg.nodeId, edge_1.EdgeType.DefinedByOnCall);
             matchedParameters.add(name);
         }
-        else if (specialDotParameter !== undefined && specialDotParameter.name) {
+        else if (specialDotParameter?.name) {
             logger_1.dataflowLogger.trace(`mapping named argument "${name}" to dot-dot-dot parameter`);
             graph.addEdge(arg.nodeId, specialDotParameter.name.info.id, edge_1.EdgeType.DefinesOnCall);
             graph.addEdge(specialDotParameter.name.info.id, arg.nodeId, edge_1.EdgeType.DefinedByOnCall);
         }
     }
-    const remainingParameter = params.filter(p => !p || !p.name || !matchedParameters.has(p.name.content));
+    const remainingParameter = params.filter(p => !p?.name || !matchedParameters.has(p.name.content));
     const remainingArguments = args.filter(a => !(0, graph_1.isNamedArgument)(a));
     for (let i = 0; i < remainingArguments.length; i++) {
         const arg = remainingArguments[i];
@@ -169,14 +169,14 @@ function linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefin
         return;
     }
     const readBits = edge_1.EdgeType.Reads | edge_1.EdgeType.Calls;
-    const functionDefinitionReadIds = [...edges].filter(([_, e]) => (0, edge_1.edgeDoesNotIncludeType)(e.types, edge_1.EdgeType.Argument)
+    const functionDefinitionReadIds = edges.entries().filter(([_, e]) => (0, edge_1.edgeDoesNotIncludeType)(e.types, edge_1.EdgeType.Argument)
         && (0, edge_1.edgeIncludesType)(e.types, readBits)).map(([target, _]) => target);
     const functionDefs = getAllLinkedFunctionDefinitions(new Set(functionDefinitionReadIds), graph)[0];
     for (const def of functionDefs.values()) {
         (0, assert_1.guard)(def.tag === vertex_1.VertexType.FunctionDefinition, () => `expected function definition, but got ${def.tag}`);
         linkFunctionCallWithSingleTarget(graph, def, info, idMap);
     }
-    if (thisGraph.isRoot(id)) {
+    if (thisGraph.isRoot(id) && functionDefs.size > 0) {
         calledFunctionDefinitions.push({ functionCall: id, called: [...functionDefs.values()] });
     }
 }
@@ -189,7 +189,7 @@ function linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefin
  * @param thisGraph - The graph to search for function calls in
  */
 function linkFunctionCalls(graph, idMap, thisGraph) {
-    const functionCalls = [...thisGraph.vertices(true)]
+    const functionCalls = thisGraph.vertices(true)
         .filter(([_, info]) => info.tag === vertex_1.VertexType.FunctionCall);
     const calledFunctionDefinitions = [];
     for (const [id, info] of functionCalls) {

package/dataflow/internal/process/functions/call/built-in/built-in-access.js

@@ -112,7 +112,7 @@ function processNumberBasedAccess(data, name, args, rootId, config, head) {
         data.environment.current.memory.set(':=', existing);
     }
     if (head.value && outInfo.definitionRootNodes.length > 0) {
-        (0, built_in_assignment_1.markAsAssignment)(fnCall.information, { type: identifier_1.ReferenceType.Variable, name: head.value.lexeme ?? '', nodeId: head.value.info.id, definedAt: rootId, controlDependencies: [] }, outInfo.definitionRootNodes, rootId, data.flowrConfig);
+        (0, built_in_assignment_1.markAsAssignment)(fnCall.information, { type: identifier_1.ReferenceType.Variable, name: head.value.lexeme ?? '', nodeId: head.value.info.id, definedAt: rootId, controlDependencies: [] }, outInfo.definitionRootNodes, rootId, data);
     }
     if (data.flowrConfig.solver.pointerTracking) {
         referenceAccessedIndices(args, data, fnCall, rootId, true);