@eagleoutice/flowr 2.6.1 → 2.6.3

package/dataflow/cluster.js

@@ -4,6 +4,9 @@ exports.findAllClusters = findAllClusters;
 const edge_1 = require("./graph/edge");
 const vertex_1 = require("./graph/vertex");
 const assert_1 = require("../util/assert");
+/**
+ * Find all clusters in the given dataflow graph.
+ */
 function findAllClusters(graph) {
     const clusters = [];
     // we reverse the vertices since dependencies usually point "backwards" from later nodes

package/dataflow/environments/append.d.ts

@@ -1,4 +1,4 @@
-import type { REnvironmentInformation } from './environment';
+import { type REnvironmentInformation } from './environment';
 /**
  * Adds all writes of `next` to `base` (i.e., the operations of `next` *might* happen).
  */

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

@@ -1,5 +1,4 @@
-import type { BuiltInMappingName, ConfigOfBuiltInMappingName } from './built-in';
-import { BuiltIns } from './built-in';
+import { type BuiltInMappingName, type ConfigOfBuiltInMappingName, BuiltIns } from './built-in';
 import type { Identifier } from './identifier';
 export interface BaseBuiltInDefinition {
     /** The type of the built-in configuration */
@@ -11,7 +10,6 @@ export interface BaseBuiltInDefinition {
 }
 /**
  * Define a built-in constant (like `NULL` or `TRUE`) and the TS value it should have
- *
  * @template Value - The type of the constant value
  */
 export interface BuiltInConstantDefinition<Value> extends BaseBuiltInDefinition {
@@ -21,7 +19,6 @@ export interface BuiltInConstantDefinition<Value> extends BaseBuiltInDefinition
 }
 /**
  * Define a built-in function (like `print` or `c`) and the processor to use.
- *
  * @template BuiltInProcessor - The processor to use for this function
  */
 export interface BuiltInFunctionDefinition<BuiltInProcessor extends BuiltInMappingName> extends BaseBuiltInDefinition {
@@ -52,7 +49,6 @@ export type BuiltInDefinitions = BuiltInDefinition[];
 export declare function getDefaultBuiltInDefinitions(): BuiltIns;
 /**
  * Get the {@link BuiltIns#builtInMemory} and {@link BuiltIns#emptyBuiltInMemory} for the given list of built-in definitions.
- *
  * @param definitions - the list of built-in definitions
  * @param loadDefaults - whether to first add the {@link DefaultBuiltinConfig} before the given {@link definitions}
  */

package/dataflow/environments/built-in-config.js

@@ -16,7 +16,6 @@ function getDefaultBuiltInDefinitions() {
 }
 /**
  * Get the {@link BuiltIns#builtInMemory} and {@link BuiltIns#emptyBuiltInMemory} for the given list of built-in definitions.
- *
  * @param definitions - the list of built-in definitions
  * @param loadDefaults - whether to first add the {@link DefaultBuiltinConfig} before the given {@link definitions}
  */

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

@@ -8,15 +8,14 @@ import { processPipe } from '../internal/process/functions/call/built-in/built-i
 import { processForLoop } from '../internal/process/functions/call/built-in/built-in-for-loop';
 import { processRepeatLoop } from '../internal/process/functions/call/built-in/built-in-repeat-loop';
 import { processWhileLoop } from '../internal/process/functions/call/built-in/built-in-while-loop';
-import type { Identifier, IdentifierDefinition, IdentifierReference } from './identifier';
-import { ReferenceType } from './identifier';
+import { type Identifier, type IdentifierDefinition, type IdentifierReference, ReferenceType } from './identifier';
 import { processReplacementFunction } from '../internal/process/functions/call/built-in/built-in-replacement';
 import { processQuote } from '../internal/process/functions/call/built-in/built-in-quote';
 import { processFunctionDefinition } from '../internal/process/functions/call/built-in/built-in-function-definition';
 import { processExpressionList } from '../internal/process/functions/call/built-in/built-in-expression-list';
 import { processGet } from '../internal/process/functions/call/built-in/built-in-get';
 import type { AstIdMap, ParentInformation, RNodeWithParent } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { RFunctionArgument } from '../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import { type RFunctionArgument } from '../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { RSymbol } from '../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { processLibrary } from '../internal/process/functions/call/built-in/built-in-library';
@@ -35,7 +34,13 @@ import type { DataflowGraph } from '../graph/graph';
 import type { VariableResolve } from '../../config';
 import type { BuiltInConstantDefinition, BuiltInDefinition, BuiltInFunctionDefinition, BuiltInReplacementDefinition } from './built-in-config';
 export type BuiltIn = `built-in:${string}`;
+/**
+ * Generate a built-in id for the given name
+ */
 export declare function builtInId(name: string): BuiltIn;
+/**
+ * Checks whether the given name is a built-in identifier
+ */
 export declare function isBuiltIn(name: NodeId | string): name is BuiltIn;
 export type BuiltInIdentifierProcessor = <OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>) => DataflowInformation;
 export type BuiltInIdentifierProcessorWithConfig<Config> = <OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: Config) => DataflowInformation;
@@ -58,7 +63,8 @@ export interface DefaultBuiltInProcessorConfiguration extends ForceArguments {
     readonly hasUnknownSideEffects?: boolean | LinkTo<RegExp | string>;
     /** record mapping the actual function name called to the arguments that should be treated as function calls */
     readonly treatAsFnCall?: Record<string, readonly string[]>;
-    /** Name that should be used for the origin (useful when needing to differentiate between
+    /**
+     * Name that should be used for the origin (useful when needing to differentiate between
      * functions like 'return' that use the default builtin processor)
      */
     readonly useAsProcessor?: UseAsProcessors;
@@ -125,7 +131,6 @@ export declare class BuiltIns {
      * 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: BuiltInMemory;

package/dataflow/environments/built-in.js

@@ -32,9 +32,15 @@ const vertex_1 = require("../graph/vertex");
 const type_1 = require("../../r-bridge/lang-4.x/ast/model/type");
 const unknown_side_effect_1 = require("../graph/unknown-side-effect");
 const resolve_1 = require("../eval/resolve/resolve");
+/**
+ * Generate a built-in id for the given name
+ */
 function builtInId(name) {
     return `built-in:${name}`;
 }
+/**
+ * Checks whether the given name is a built-in identifier
+ */
 function isBuiltIn(name) {
     return String(name).startsWith('built-in:');
 }
@@ -218,7 +224,6 @@ class BuiltIns {
      * 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();

package/dataflow/environments/clone.d.ts

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

package/dataflow/environments/clone.js

@@ -11,13 +11,23 @@ function cloneEnvironment(environment, recurseParents) {
     }
     /* make sure the clone has the same id */
     const clone = new environment_1.Environment(recurseParents ? cloneEnvironment(environment.parent, recurseParents) : environment.parent, environment.builtInEnv);
-    clone.memory = new Map(JSON.parse(JSON.stringify([...environment.memory])));
+    if (environment.memory.size < 10) {
+        clone.memory = new Map(JSON.parse(JSON.stringify(environment.memory.entries().toArray())));
+    }
+    else {
+        clone.memory = new Map(environment.memory.entries()
+            .map(([k, v]) => [k,
+            v.map(s => ({
+                ...s,
+                controlDependencies: s.controlDependencies?.slice()
+            }))
+        ]));
+    }
     return clone;
 }
 /**
  * Produce a clone of the given environment information.
  * @param environment        - The environment information to clone.
- * @param builtInEnvironment - The built-in environment
  * @param recurseParents     - Whether to clone the parent environments as well.
  */
 function cloneEnvironmentInformation(environment, recurseParents = true) {

package/dataflow/environments/default-builtin-config.d.ts

@@ -13,4 +13,7 @@ export declare const GgPlotAddons: string[];
  * Contains the built-in definitions recognized by flowR
  */
 export declare const DefaultBuiltinConfig: BuiltInDefinitions;
+/**
+ *
+ */
 export declare function getDefaultProcessor(name: string): BuiltInMappingName | 'unnamed' | undefined;

package/dataflow/environments/default-builtin-config.js

@@ -93,7 +93,7 @@ function toRegex(n) {
  * Contains the built-in definitions recognized by flowR
  */
 exports.DefaultBuiltinConfig = [
-    { type: 'constant', names: ['NULL', 'NA'], value: null, assumePrimitive: true },
+    { type: 'constant', names: ['NULL', 'NA', 'NaN', 'NA_integer_', 'NA_real_', 'NA_complex_', 'NA_character_'], value: null, assumePrimitive: true },
     { type: 'constant', names: ['TRUE', 'T'], value: true, assumePrimitive: true },
     { type: 'constant', names: ['FALSE', 'F'], value: false, assumePrimitive: true },
     {
@@ -302,6 +302,9 @@ exports.DefaultBuiltinConfig = [
         }
     }
 ];
+/**
+ *
+ */
 function getDefaultProcessor(name) {
     if (name.startsWith(unnamed_call_handling_1.UnnamedFunctionCallPrefix)) {
         return 'unnamed';

package/dataflow/environments/diff.d.ts

@@ -1,6 +1,15 @@
-import type { GenericDifferenceInformation, WriteableDifferenceReport } from '../../util/diff';
-import type { IEnvironment, REnvironmentInformation } from './environment';
+import { type GenericDifferenceInformation, type WriteableDifferenceReport } from '../../util/diff';
+import { type IEnvironment, type REnvironmentInformation } from './environment';
 import type { IdentifierReference } from './identifier';
+/**
+ * Compares two identifier references and reports differences.
+ */
 export declare function diffIdentifierReferences<Report extends WriteableDifferenceReport>(a: IdentifierReference | undefined, b: IdentifierReference | undefined, info: GenericDifferenceInformation<Report>): void;
+/**
+ * Compares two environments and reports differences.
+ */
 export declare function diffEnvironment<Report extends WriteableDifferenceReport>(a: IEnvironment | undefined, b: IEnvironment | undefined, info: GenericDifferenceInformation<Report>, depth: number): void;
+/**
+ * Compares two REnvironmentInformation objects and reports differences.
+ */
 export declare function diffEnvironmentInformation<Report extends WriteableDifferenceReport>(a: REnvironmentInformation | undefined, b: REnvironmentInformation | undefined, info: GenericDifferenceInformation<Report>): void;

package/dataflow/environments/diff.js

@@ -7,6 +7,9 @@ const diff_1 = require("../../util/diff");
 const environment_1 = require("./environment");
 const json_1 = require("../../util/json");
 const info_1 = require("../info");
+/**
+ * Compares two identifier references and reports differences.
+ */
 function diffIdentifierReferences(a, b, info) {
     if (a === undefined || b === undefined) {
         if (a !== b) {
@@ -30,8 +33,8 @@ function diffMemory(a, b, info) {
             continue;
         }
         // we sort both value arrays by their id so that we have no problems with differently ordered arrays (which have no impact)
-        const sorted = [...value].sort((a, b) => String(a.nodeId).localeCompare(String(b.nodeId)));
-        const sorted2 = [...value2].sort((a, b) => String(a.nodeId).localeCompare(String(b.nodeId)));
+        const sorted = value.slice().sort((a, b) => String(a.nodeId).localeCompare(String(b.nodeId)));
+        const sorted2 = value2.slice().sort((a, b) => String(a.nodeId).localeCompare(String(b.nodeId)));
         for (let i = 0; i < value.length; ++i) {
             const aVal = sorted[i];
             const bVal = sorted2[i];
@@ -51,6 +54,9 @@ function diffMemory(a, b, info) {
         }
     }
 }
+/**
+ * Compares two environments and reports differences.
+ */
 function diffEnvironment(a, b, info, depth) {
     if (a === undefined || b === undefined) {
         if (a !== b) {
@@ -71,6 +77,9 @@ function diffEnvironment(a, b, info, depth) {
     diffMemory(a, b, { ...info, position: `${info.position}[at level: ${depth}] ` });
     diffEnvironment(a.parent, b.parent, { ...info, position: `${info.position}Parents of ${a.id} & ${b.id}. ` }, depth--);
 }
+/**
+ * Compares two REnvironmentInformation objects and reports differences.
+ */
 function diffEnvironmentInformation(a, b, info) {
     if (a === undefined || b === undefined) {
         if (a !== b) {

package/dataflow/environments/environment.d.ts

@@ -1,7 +1,6 @@
 /**
  * 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';
@@ -12,6 +11,9 @@ 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[];
 /** A single entry/scope within an {@link REnvironmentInformation} */
 export interface IEnvironment {
@@ -55,8 +57,6 @@ export interface WorkingDirectoryReference {
  * 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.
- *
- *
  * @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
  * @see {@link makeReferenceMaybe} - to attach control dependencies to a reference

package/dataflow/environments/environment.js

@@ -29,16 +29,15 @@ function makeReferenceMaybe(ref, graph, environments, includeDefs, defaultCd = u
             }
         }
     }
-    const node = graph.get(ref.nodeId, true);
+    const node = graph.getVertex(ref.nodeId, true);
     if (node) {
-        const [fst] = node;
-        if (fst.cds) {
-            if (defaultCd && !fst.cds.find(c => c.id === defaultCd.id && c.when === defaultCd.when)) {
-                fst.cds.push(defaultCd);
+        if (node.cds) {
+            if (defaultCd && !node.cds.find(c => c.id === defaultCd.id && c.when === defaultCd.when)) {
+                node.cds.push(defaultCd);
             }
         }
         else {
-            fst.cds = defaultCd ? [defaultCd] : [];
+            node.cds = defaultCd ? [defaultCd] : [];
         }
     }
     if (ref.controlDependencies) {
@@ -51,6 +50,9 @@ function makeReferenceMaybe(ref, graph, environments, includeDefs, defaultCd = u
     }
     return ref;
 }
+/**
+ *
+ */
 function makeAllMaybe(references, graph, environments, includeDefs, defaultCd = undefined) {
     return references?.map(ref => makeReferenceMaybe(ref, graph, environments, includeDefs, defaultCd)) ?? [];
 }

package/dataflow/environments/identifier.d.ts

@@ -14,7 +14,6 @@ export type Identifier = string & {
  * a function when resolving an {@link Identifier|identifier}.
  * In `c <- 3; print(c(1, 2))` the call to `c` works normally (as the vector constructor),
  * while writing `c <- function(...) ..1` overshadows the built-in and causes `print` to only output the first element.
- *
  * @see {@link isReferenceType} - for checking if a (potentially joint) reference type contains a certain type
  * @see {@link ReferenceTypeReverseMapping} - for debugging
  */
@@ -45,7 +44,6 @@ export declare function isReferenceType(t: ReferenceType, target: ReferenceType)
 /**
  * Describes all types of reference (definitions) that can appear within a graph (i.e., that are not built-in like the
  * default definition for the assignment operator `<-`).
- *
  * @see {@link InGraphIdentifierDefinition} - for the definition of an identifier within the graph
  */
 export type InGraphReferenceType = Exclude<ReferenceType, ReferenceType.BuiltInConstant | ReferenceType.BuiltInFunction>;
@@ -61,7 +59,6 @@ export type InGraphReferenceType = Exclude<ReferenceType, ReferenceType.BuiltInC
  * they indicate the references that are currently (during the analysis at this given node)
  * {@link DataflowInformation#in|read (`in`)}, {@link DataflowInformation#out|written (`out`)},
  * or {@link DataflowInformation#unknownReferences|unknown (`unknownReferences`)}.
- *
  * @see {@link InGraphIdentifierDefinition}
  */
 export interface IdentifierReference {
@@ -88,7 +85,6 @@ export interface IdentifierReference {
  * Within a code snippet like `a <- 3`, the symbol processor will first create an
  * {@link IdentifierReference|identifier reference} for `a` to reference the use
  * and then promote it to an {@link InGraphIdentifierDefinition|identifier definition}.
- *
  * @see {@link IdentifierReference}
  */
 export interface InGraphIdentifierDefinition extends IdentifierReference {

package/dataflow/environments/identifier.js

@@ -11,7 +11,6 @@ exports.isReferenceType = isReferenceType;
  * a function when resolving an {@link Identifier|identifier}.
  * In `c <- 3; print(c(1, 2))` the call to `c` works normally (as the vector constructor),
  * while writing `c <- function(...) ..1` overshadows the built-in and causes `print` to only output the first element.
- *
  * @see {@link isReferenceType} - for checking if a (potentially joint) reference type contains a certain type
  * @see {@link ReferenceTypeReverseMapping} - for debugging
  */

package/dataflow/environments/overwrite.d.ts

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

package/dataflow/environments/overwrite.js

@@ -1,40 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.overwriteIEnvironmentWith = overwriteIEnvironmentWith;
 exports.overwriteEnvironment = overwriteEnvironment;
 const assert_1 = require("../../util/assert");
 const environment_1 = require("./environment");
-const log_1 = require("../../util/log");
 function anyIsMaybeOrEmpty(values) {
-    if (values.length === 0) {
-        return true;
-    }
-    for (const val of values) {
-        if (val.controlDependencies !== undefined) {
-            return true;
-        }
-    }
-    return false;
+    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) {
-        if (values.length > 1_000_000) {
-            log_1.log.warn(`Overwriting environment with ${values.length} definitions for ${key}`);
-        }
         const hasMaybe = applyCds !== undefined ? true : anyIsMaybeOrEmpty(values);
         if (hasMaybe) {
             const old = map.get(key);
             // we need to make a copy to avoid side effects for old reference in other environments
-            const updatedOld = [...old ?? []];
+            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: applyCds.concat(v.controlDependencies ?? [])
+                            controlDependencies: v.controlDependencies ? applyCds.concat(v.controlDependencies) : applyCds.slice()
                         });
                     }
                     else {

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

@@ -1,16 +1,16 @@
 import type { REnvironmentInformation } from './environment';
 import { Ternary } from '../../util/logic';
-import type { Identifier, IdentifierDefinition } from './identifier';
-import { ReferenceType } from './identifier';
+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.
- *
  * @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 resolvesToBuiltInConstant(name: Identifier | undefined, environment: REnvironmentInformation, wantedValue: unknown): Ternary;

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

@@ -22,11 +22,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
- *
  * @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.
  */
@@ -56,6 +54,9 @@ function resolveByName(name, environment, target = identifier_1.ReferenceType.Un
         return builtIns;
     }
 }
+/**
+ *
+ */
 function resolvesToBuiltInConstant(name, environment, wantedValue) {
     if (name === undefined) {
         return logic_1.Ternary.Never;

package/dataflow/environments/scoping.d.ts

@@ -1,4 +1,11 @@
-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) */
+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;
+/**
+ * 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;

package/dataflow/environments/scoping.js

@@ -4,13 +4,20 @@ exports.pushLocalEnvironment = pushLocalEnvironment;
 exports.popLocalEnvironment = popLocalEnvironment;
 const environment_1 = require("./environment");
 const assert_1 = require("../../util/assert");
-/** Add a new local environment scope to the stack, returns the modified variant - sharing the original environments in the stack (no deep-clone) */
+/**
+ * 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
+ */
 function pushLocalEnvironment(base) {
     return {
         current: new environment_1.Environment(base.current),
         level: base.level + 1
     };
 }
+/**
+ * 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
+ */
 function popLocalEnvironment(base) {
     (0, assert_1.guard)(base.level > 0, 'cannot remove the global/root environment');
     const parent = base.current.parent;

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

@@ -1,10 +1,10 @@
 import { VariableResolve } from '../../../config';
 import type { AstIdMap, RNodeWithParent } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
-import type { REnvironmentInformation } from '../../environments/environment';
-import type { Identifier } from '../../environments/identifier';
+import { type NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { type REnvironmentInformation } from '../../environments/environment';
+import { type Identifier } from '../../environments/identifier';
 import type { DataflowGraph } from '../../graph/graph';
-import type { Lift, Value, ValueSet } from '../values/r-value';
+import { type Lift, type Value, type ValueSet } from '../values/r-value';
 export type ResolveResult = Lift<ValueSet<Value[]>>;
 export interface ResolveInfo {
     /** The current environment used for name resolution */
@@ -26,7 +26,6 @@ export interface ResolveInfo {
  * the sourceIds value field of their InGraphIdentifierDefinition. This enables
  * 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
@@ -45,7 +44,6 @@ export declare function getAliases(sourceIds: readonly NodeId[], dataflow: Dataf
  * This function is also used by the Resolve Value Query and the Dependency Query
  * 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
@@ -59,8 +57,6 @@ export declare function resolveIdToValue(id: NodeId | RNodeWithParent | undefine
  *
  * Uses the aliases that were tracked in the environments (by the
  * {@link getAliases} function) to resolve a node to a value.
- *
- *
  * @param resolve    - Variable resolve mode
  * @param identifier - Identifier to resolve
  * @param use        - Environment to use
@@ -73,7 +69,6 @@ export declare function trackAliasInEnvironments(resolve: VariableResolve, ident
  * Please use {@link resolveIdToValue}
  *
  * Tries to resolve the value of a node by traversing the dataflow graph
- *
  * @param id    - node to resolve
  * @param graph - dataflow graph
  * @param idMap - idmap of dataflow graph
@@ -84,7 +79,6 @@ export declare function trackAliasesInGraph(id: NodeId, graph: DataflowGraph, id
  * Please use {@link resolveIdToValue}
  *
  * Resolve an Identifier to a constant, if the identifier is a constant
- *
  * @param name               - Identifier to resolve
  * @param environment        - Environment to use
  * @returns Value of Constant or Top

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

@@ -77,7 +77,6 @@ function getUseAlias(sourceId, dataflow, environment) {
  * the sourceIds value field of their InGraphIdentifierDefinition. This enables
  * 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
@@ -109,7 +108,6 @@ function getAliases(sourceIds, dataflow, environment) {
  * This function is also used by the Resolve Value Query and the Dependency Query
  * 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
@@ -157,8 +155,6 @@ function resolveIdToValue(id, { environment, graph, idMap, full = true, resolve
  *
  * Uses the aliases that were tracked in the environments (by the
  * {@link getAliases} function) to resolve a node to a value.
- *
- *
  * @param resolve    - Variable resolve mode
  * @param identifier - Identifier to resolve
  * @param use        - Environment to use
@@ -256,20 +252,22 @@ function isNestedInLoop(node, ast) {
  * Please use {@link resolveIdToValue}
  *
  * Tries to resolve the value of a node by traversing the dataflow graph
- *
  * @param id    - node to resolve
  * @param graph - dataflow graph
  * @param idMap - idmap of dataflow graph
  * @returns Value of node or Top/Bottom
  */
 function trackAliasesInGraph(id, graph, idMap) {
+    if (!graph.get(id)) {
+        return r_value_1.Bottom;
+    }
     idMap ??= graph.idMap;
     (0, assert_1.guard)(idMap !== undefined, 'The ID map is required to get the lineage of a node');
     const queue = new visiting_queue_1.VisitingQueue(25);
     const clean = (0, environment_1.initializeCleanEnvironments)();
     const cleanFingerprint = (0, fingerprint_1.envFingerprint)(clean);
     queue.add(id, clean, cleanFingerprint, false);
-    let forceBot = false;
+    let forceTop = false;
     const resultIds = [];
     while (queue.nonEmpty()) {
         const { id, baseEnvironment } = queue.next();
@@ -284,15 +282,15 @@ function trackAliasesInGraph(id, graph, idMap) {
             if (target === undefined) {
                 continue;
             }
-            if (target.type === type_1.RType.WhileLoop || target.type === type_1.RType.RepeatLoop) {
-                forceBot = true;
+            if (target.type === type_1.RType.WhileLoop || target.type === type_1.RType.RepeatLoop || target.type === type_1.RType.ForLoop) {
+                forceTop = true;
                 break;
             }
         }
-        if (!forceBot && (cds?.length === 0 && isNestedInLoop(idMap.get(id), idMap))) {
-            forceBot = true;
+        if (!forceTop && (cds?.length === 0 && isNestedInLoop(idMap.get(id), idMap))) {
+            forceTop = true;
         }
-        if (forceBot) {
+        if (forceTop) {
             break;
         }
         if (vertex.tag === vertex_1.VertexType.Value) {
@@ -318,8 +316,8 @@ function trackAliasesInGraph(id, graph, idMap) {
             }
         }
     }
-    if (forceBot || resultIds.length === 0) {
-        return r_value_1.Bottom;
+    if (forceTop || resultIds.length === 0) {
+        return r_value_1.Top;
     }
     const values = new Set();
     for (const id of resultIds) {
@@ -334,7 +332,6 @@ function trackAliasesInGraph(id, graph, idMap) {
  * Please use {@link resolveIdToValue}
  *
  * Resolve an Identifier to a constant, if the identifier is a constant
- *
  * @param name               - Identifier to resolve
  * @param environment        - Environment to use
  * @returns Value of Constant or Top