@eagleoutice/flowr 2.3.0 → 2.4.1

package/dataflow/environments/built-in.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EmptyBuiltInMemory = exports.BuiltInMemory = exports.BuiltInEvalHandlerMapper = exports.BuiltInProcessorMapper = void 0;
+exports.BuiltIns = exports.BuiltInEvalHandlerMapper = exports.BuiltInProcessorMapper = void 0;
 exports.builtInId = builtInId;
 exports.isBuiltIn = isBuiltIn;
 exports.registerBuiltInFunctions = registerBuiltInFunctions;
@@ -25,8 +25,6 @@ const edge_1 = require("../graph/edge");
 const built_in_library_1 = require("../internal/process/functions/call/built-in/built-in-library");
 const built_in_source_1 = require("../internal/process/functions/call/built-in/built-in-source");
 const built_in_apply_1 = require("../internal/process/functions/call/built-in/built-in-apply");
-const built_in_config_1 = require("./built-in-config");
-const default_builtin_config_1 = require("./default-builtin-config");
 const built_in_list_1 = require("../internal/process/functions/call/built-in/built-in-list");
 const built_in_vector_1 = require("../internal/process/functions/call/built-in/built-in-vector");
 const built_in_rm_1 = require("../internal/process/functions/call/built-in/built-in-rm");
@@ -41,30 +39,31 @@ function builtInId(name) {
 function isBuiltIn(name) {
     return String(name).startsWith('built-in:');
 }
-function defaultBuiltInProcessor(name, args, rootId, data, config) {
-    const { information: res, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs, origin: config.useAsProcessor ?? 'builtin:default' });
-    if (config.returnsNthArgument !== undefined) {
-        const arg = config.returnsNthArgument === 'last' ? processedArguments[args.length - 1] : processedArguments[config.returnsNthArgument];
+function defaultBuiltInProcessor(name, args, rootId, data, { returnsNthArgument, useAsProcessor, forceArgs, readAllArguments, cfg, hasUnknownSideEffects, treatAsFnCall }) {
+    const activeProcessor = useAsProcessor ?? 'builtin:default';
+    const { information: res, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs, origin: activeProcessor });
+    if (returnsNthArgument !== undefined) {
+        const arg = returnsNthArgument === 'last' ? processedArguments[args.length - 1] : processedArguments[returnsNthArgument];
         if (arg !== undefined) {
             res.graph.addEdge(rootId, arg.entryPoint, edge_1.EdgeType.Returns);
         }
     }
-    if (config.readAllArguments) {
+    if (readAllArguments) {
         for (const arg of processedArguments) {
             if (arg) {
                 res.graph.addEdge(rootId, arg.entryPoint, edge_1.EdgeType.Reads);
             }
         }
     }
-    if (config.hasUnknownSideEffects) {
-        if (typeof config.hasUnknownSideEffects !== 'boolean') {
-            (0, unknown_side_effect_1.handleUnknownSideEffect)(res.graph, res.environment, rootId, config.hasUnknownSideEffects);
+    if (hasUnknownSideEffects) {
+        if (typeof hasUnknownSideEffects !== 'boolean') {
+            (0, unknown_side_effect_1.handleUnknownSideEffect)(res.graph, res.environment, rootId, hasUnknownSideEffects);
         }
         else {
             (0, unknown_side_effect_1.handleUnknownSideEffect)(res.graph, res.environment, rootId);
         }
     }
-    const fnCallNames = config.treatAsFnCall?.[name.content];
+    const fnCallNames = treatAsFnCall?.[name.content];
     if (fnCallNames) {
         for (const arg of args) {
             if (arg !== r_function_call_1.EmptyArgument && arg.value && fnCallNames.includes(arg.name?.content)) {
@@ -90,17 +89,17 @@ function defaultBuiltInProcessor(name, args, rootId, data, config) {
                     environment: data.environment,
                     onlyBuiltin: false,
                     cds: data.controlDependencies,
-                    origin: [config.useAsProcessor ?? 'builtin:default']
+                    origin: [activeProcessor]
                 });
             }
         }
     }
-    if (config.cfg !== undefined) {
-        res.exitPoints = [...res.exitPoints, { type: config.cfg, nodeId: rootId, controlDependencies: data.controlDependencies }];
+    if (cfg !== undefined) {
+        res.exitPoints.push({ type: cfg, nodeId: rootId, controlDependencies: data.controlDependencies });
     }
     return res;
 }
-function registerBuiltInFunctions(both, names, processor, config) {
+function registerBuiltInFunctions(both, names, processor, config, builtIns) {
     for (const name of names) {
         (0, assert_1.guard)(processor !== undefined, `Processor for ${name} is undefined, maybe you have an import loop? You may run 'npm run detect-circular-deps' - although by far not all are bad`);
         const id = builtInId(name);
@@ -113,10 +112,7 @@ function registerBuiltInFunctions(both, names, processor, config) {
                 name,
                 nodeId: id
             }];
-        exports.BuiltInMemory.set(name, d);
-        if (both) {
-            exports.EmptyBuiltInMemory.set(name, d);
-        }
+        builtIns.set(name, d, both);
     }
 }
 exports.BuiltInProcessorMapper = {
@@ -148,7 +144,107 @@ exports.BuiltInEvalHandlerMapper = {
     'built-in:+': resolve_1.resolveAsPlus,
     'built-in:-': resolve_1.resolveAsMinus
 };
-exports.BuiltInMemory = new Map();
-exports.EmptyBuiltInMemory = new Map();
-(0, built_in_config_1.registerBuiltInDefinitions)(default_builtin_config_1.DefaultBuiltinConfig);
+class BuiltIns {
+    /**
+     * Register a built-in constant (like `NULL` or `TRUE`) to the given {@link builtIns}
+     */
+    registerBuiltInConstant({ names, value, assumePrimitive }) {
+        for (const name of names) {
+            const id = builtInId(name);
+            const d = [{
+                    type: identifier_1.ReferenceType.BuiltInConstant,
+                    definedAt: id,
+                    controlDependencies: undefined,
+                    value,
+                    name,
+                    nodeId: id
+                }];
+            this.set(name, d, assumePrimitive);
+        }
+    }
+    /**
+     * Register a built-in function (like `print` or `c`) to the given {@link builtIns}
+     */
+    registerBuiltInFunctions({ names, processor, config, assumePrimitive }) {
+        const mappedProcessor = exports.BuiltInProcessorMapper[processor];
+        (0, assert_1.guard)(mappedProcessor !== undefined, () => `Processor for ${processor} is undefined! Please pass a valid builtin name ${JSON.stringify(Object.keys(exports.BuiltInProcessorMapper))}!`);
+        for (const name of names) {
+            (0, assert_1.guard)(processor !== undefined, `Processor for ${name} is undefined, maybe you have an import loop? You may run 'npm run detect-circular-deps' - although by far not all are bad`);
+            const id = builtInId(name);
+            const d = [{
+                    type: identifier_1.ReferenceType.BuiltInFunction,
+                    definedAt: id,
+                    controlDependencies: undefined,
+                    /* eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-argument */
+                    processor: (name, args, rootId, data) => mappedProcessor(name, args, rootId, data, config),
+                    config,
+                    name,
+                    nodeId: id
+                }];
+            this.set(name, d, assumePrimitive);
+        }
+    }
+    /**
+     * Registers all combinations of replacements
+     */
+    registerReplacementFunctions({ names, suffixes, assumePrimitive, config }) {
+        const replacer = exports.BuiltInProcessorMapper['builtin:replacement'];
+        (0, assert_1.guard)(replacer !== undefined, () => 'Processor for builtin:replacement is undefined!');
+        for (const assignment of names) {
+            for (const suffix of suffixes) {
+                const effectiveName = `${assignment}${suffix}`;
+                const id = builtInId(effectiveName);
+                const d = [{
+                        type: identifier_1.ReferenceType.BuiltInFunction,
+                        definedAt: id,
+                        processor: (name, args, rootId, data) => replacer(name, args, rootId, data, { makeMaybe: true, assignmentOperator: suffix, readIndices: config.readIndices }),
+                        config: {
+                            ...config,
+                            assignmentOperator: suffix,
+                            makeMaybe: true
+                        },
+                        name: effectiveName,
+                        controlDependencies: undefined,
+                        nodeId: id
+                    }];
+                this.set(effectiveName, d, assumePrimitive);
+            }
+        }
+    }
+    /**
+     * Register a single {@link BuiltInDefinition} to the given memories in {@link builtIns}
+     */
+    registerBuiltInDefinition(definition) {
+        switch (definition.type) {
+            case 'constant':
+                return this.registerBuiltInConstant(definition);
+            case 'function':
+                return this.registerBuiltInFunctions(definition);
+            case 'replacement':
+                return this.registerReplacementFunctions(definition);
+        }
+    }
+    /**
+     * 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}.
+     */
+    builtInMemory = new Map();
+    /**
+     * The twin of the {@link builtInMemory} 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 builtInMemory}
+     */
+    emptyBuiltInMemory = new Map();
+    set(identifier, definition, includeInEmptyMemory) {
+        this.builtInMemory.set(identifier, definition);
+        if (includeInEmptyMemory) {
+            this.emptyBuiltInMemory.set(identifier, definition);
+        }
+    }
+}
+exports.BuiltIns = BuiltIns;
 //# sourceMappingURL=built-in.js.map

package/dataflow/environments/clone.d.ts

@@ -1,7 +1,8 @@
 import type { REnvironmentInformation } from './environment';
 /**
  * Produce a clone of the given environment information.
- * @param environment    - The environment information to clone.
- * @param recurseParents - Whether to clone the parent environments as well.
+ * @param environment        - The environment information to clone.
+ * @param builtInEnvironment - The built-in environment
+ * @param recurseParents     - Whether to clone the parent environments as well.
  */
 export declare function cloneEnvironmentInformation(environment: REnvironmentInformation, recurseParents?: boolean): REnvironmentInformation;

package/dataflow/environments/clone.js

@@ -6,18 +6,19 @@ function cloneEnvironment(environment, recurseParents) {
     if (environment === undefined) {
         return undefined;
     }
-    else if (environment.id === environment_1.BuiltInEnvironment.id) {
-        return environment_1.BuiltInEnvironment;
+    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);
+    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 recurseParents - Whether to clone the parent environments as well.
+ * @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) {
     return {

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;