@eagleoutice/flowr 2.6.1 → 2.6.2

package/core/steps/pipeline-step.d.ts

@@ -1,6 +1,5 @@
 /**
  * Defines the {@link IPipelineStep} interface which specifies all data available for a single step.
- *
  * @module
  */
 import type { MergeableRecord } from '../../util/objects';

package/core/steps/pipeline-step.js

@@ -1,7 +1,6 @@
 "use strict";
 /**
  * Defines the {@link IPipelineStep} interface which specifies all data available for a single step.
- *
  * @module
  */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dataflow/cluster.d.ts

@@ -17,4 +17,7 @@ export interface DataflowGraphCluster {
     /** If the cluster contains unknown side effects */
     readonly hasUnknownSideEffects: boolean;
 }
+/**
+ * Find all clusters in the given dataflow graph.
+ */
 export declare function findAllClusters(graph: DataflowGraph): DataflowGraphClusters;

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,4 +1,4 @@
-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.

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

package/dataflow/environments/overwrite.js

@@ -16,6 +16,9 @@ function anyIsMaybeOrEmpty(values) {
     }
     return false;
 }
+/**
+ *
+ */
 function overwriteIEnvironmentWith(base, next, includeParent = true, applyCds) {
     (0, assert_1.guard)(base !== undefined && next !== undefined, 'can not overwrite environments with undefined');
     const map = new Map(base.memory);

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,7 @@
-import type { REnvironmentInformation } from './environment';
+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) */
 export declare function pushLocalEnvironment(base: REnvironmentInformation): REnvironmentInformation;
+/**
+ *
+ */
 export declare function popLocalEnvironment(base: REnvironmentInformation): REnvironmentInformation;

package/dataflow/environments/scoping.js

@@ -11,6 +11,9 @@ function pushLocalEnvironment(base) {
         level: base.level + 1
     };
 }
+/**
+ *
+ */
 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

package/dataflow/eval/resolve/resolve-argument.d.ts

@@ -1,4 +1,4 @@
-import type { DataflowGraph } from '../../graph/graph';
+import { type DataflowGraph } from '../../graph/graph';
 import type { DataflowGraphVertexFunctionCall } from '../../graph/vertex';
 import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { VariableResolve } from '../../../config';

package/dataflow/eval/resolve/resolve.d.ts

@@ -1,8 +1,7 @@
 import type { AstIdMap, RNodeWithParent } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { REnvironmentInformation } from '../../environments/environment';
 import type { DataflowGraph } from '../../graph/graph';
-import type { Lift, Value, ValueNumber, ValueVector } from '../values/r-value';
-import { Top } from '../values/r-value';
+import { type Lift, type Value, type ValueNumber, type ValueVector, Top } from '../values/r-value';
 import type { VariableResolve } from '../../../config';
 /**
  * Helper function used by {@link resolveIdToValue}, please use that instead, if
@@ -10,7 +9,6 @@ import type { VariableResolve } from '../../../config';
  *
  * This function converts an RNode to its Value, but also recursively resolves
  * aliases and vectors (in case of a vector).
- *
  * @param a       - Ast node to resolve
  * @param resolve - Variable resolve mode
  * @param env     - Environment to use
@@ -25,7 +23,6 @@ export declare function resolveNode(resolve: VariableResolve, a: RNodeWithParent
  *
  * This function resolves a vector function call `c` to a {@link ValueVector}
  * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
- *
  * @param resolve - Variable resolve mode
  * @param node    - Node of the vector function to resolve
  * @param env     - Environment to use
@@ -40,7 +37,6 @@ export declare function resolveAsVector(resolve: VariableResolve, node: RNodeWit
  *
  * This function resolves a binary sequence operator `:` to a {@link ValueVector} of {@link ValueNumber}s
  * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
- *
  * @param resolve  - Variable resolve mode
  * @param operator - Node of the sequence operator to resolve
  * @param env      - Environment to use
@@ -55,7 +51,6 @@ export declare function resolveAsSeq(resolve: VariableResolve, operator: RNodeWi
  *
  * This function resolves a unary plus operator `+` to a {@link ValueNumber} or {@link ValueVector} of ValueNumbers
  * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
- *
  * @param resolve  - Variable resolve mode
  * @param operator - Node of the plus operator to resolve
  * @param env      - Environment to use
@@ -70,7 +65,6 @@ export declare function resolveAsPlus(resolve: VariableResolve, operator: RNodeW
  *
  * This function resolves a unary minus operator `-` to a {@link ValueNumber} or {@link ValueVector} of ValueNumbers
  * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
- *
  * @param resolve  - Variable resolve mode
  * @param operator - Node of the minus operator to resolve
  * @param env      - Environment to use