@eagleoutice/flowr 2.8.15 → 2.9.1

package/dataflow/graph/edge.d.ts

@@ -1,14 +1,15 @@
 /**
  * An edge consist of only of the type (source and target are encoded with the Dataflow Graph).
  * Multiple edges are encoded by joining the respective type bits.
+ * @see {@link EdgeType} for the basis.
+ * @see {@link DfEdge} for helper functions.
  */
-export interface DataflowGraphEdge {
+export interface DfEdge {
     types: EdgeTypeBits;
 }
 /**
  * Represents the relationship between the source and the target vertex in the dataflow graph.
- * The actual value is represented as a bitmask so use {@link edgeTypesToNames} to get something more human-readable.
- * Similarly, you can access {@link EdgeTypeName} to access the name counterpart.
+ * The actual value is represented as a bitmask, so please refer to {@link DfEdge} for helpful functions.
  */
 export declare enum EdgeType {
     /** The edge determines that source reads target */
@@ -51,19 +52,50 @@ export declare const enum EdgeTypeName {
     NonStandardEvaluation = "non-standard-evaluation"
 }
 export type EdgeTypeBits = number;
+type DfEdgeLike = {
+    types: number;
+};
 /**
- * Only use this function to retrieve a human-readable name if you know that it is a single bitmask.
- * Otherwise, use {@link edgeTypesToNames} which handles these cases.
+ * Helper Functions to work with {@link DfEdge} and {@link EdgeType}.
  */
-export declare function edgeTypeToName(type: EdgeType): string;
-/**
- * Takes joint edge types and splits them into their individual components.
- */
-export declare function splitEdgeTypes(types: EdgeTypeBits): EdgeType[];
-/**
- * Takes joint edge types and returns their human-readable names.
- */
-export declare function edgeTypesToNames(bits: EdgeTypeBits): Set<EdgeTypeName>;
+export declare const DfEdge: {
+    /**
+     * Takes joint edge types and returns their human-readable names.
+     */
+    readonly typesToNames: (this: void, { types }: DfEdgeLike) => Set<EdgeTypeName>;
+    /**
+     * Takes joint edge types and splits them into their individual components.
+     * @example
+     * ```ts
+     * DfEdge.splitTypes({ types: EdgeType.Reads | EdgeType.DefinedBy });
+     * // returns [EdgeType.Reads, EdgeType.DefinedBy]
+     * ```
+     */
+    readonly splitTypes: (this: void, { types }: DfEdgeLike) => EdgeType[];
+    /**
+     * Only use this function to retrieve a human-readable name if you know that it is a single bitmask.
+     * Otherwise, use {@link DfEdge#typesToNames} which handles these cases.
+     */
+    readonly typeToName: (this: void, type: EdgeType) => string;
+    /**
+     * Check if the given-edge type has any of the given types.
+     * As types are bitmasks, you can combine multiple types with a bitwise OR (`|`).
+     * @example
+     *
+     * ```ts
+     * edgeIncludesType({ types: EdgeType.Reads }, EdgeType.Reads | EdgeType.DefinedBy) // true
+     *```
+     *
+     * Counterpart of {@link DfEdge#doesNotIncludeType}.
+     */
+    readonly includesType: (this: void, { types }: DfEdgeLike, typesToInclude: EdgeType) => boolean;
+    /**
+     * Check if the given-edge type does not include the given type.
+     * As types are bitmasks, you can combine multiple types with a bitwise OR (`|`).
+     * Counterpart of {@link DfEdge#includesType}.
+     */
+    readonly doesNotIncludeType: (this: void, { types }: DfEdgeLike, any: EdgeType) => boolean;
+};
 export declare const enum TraverseEdge {
     /** Do not traverse this edge */
     Never = 0,
@@ -74,23 +106,8 @@ export declare const enum TraverseEdge {
     /** Always traverse this edge */
     Always = 3
 }
-/**
- * Check if the given-edge type has any of the given types.
- * @example
- *
- * ```typescript
- * edgeIncludesType(EdgeType.Reads, EdgeType.Reads | EdgeType.DefinedBy) // true
- *```
- *
- * Counterpart of {@link edgeDoesNotIncludeType}.
- */
-export declare function edgeIncludesType(type: EdgeTypeBits, typesToInclude: EdgeTypeBits): boolean;
-/**
- * Check if the given-edge type does not include the given type.
- * Counterpart of {@link edgeIncludesType}.
- */
-export declare function edgeDoesNotIncludeType(type: EdgeTypeBits, types: EdgeTypeBits): boolean;
 /**
  * Determines whether an edge should be traversed during dataflow analysis.
  */
-export declare function shouldTraverseEdge(types: EdgeTypeBits): TraverseEdge;
+export declare function shouldTraverseEdge(e: DfEdge): TraverseEdge;
+export {};

package/dataflow/graph/edge.js

@@ -1,16 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EdgeType = void 0;
-exports.edgeTypeToName = edgeTypeToName;
-exports.splitEdgeTypes = splitEdgeTypes;
-exports.edgeTypesToNames = edgeTypesToNames;
-exports.edgeIncludesType = edgeIncludesType;
-exports.edgeDoesNotIncludeType = edgeDoesNotIncludeType;
+exports.DfEdge = exports.EdgeType = void 0;
 exports.shouldTraverseEdge = shouldTraverseEdge;
 /**
  * Represents the relationship between the source and the target vertex in the dataflow graph.
- * The actual value is represented as a bitmask so use {@link edgeTypesToNames} to get something more human-readable.
- * Similarly, you can access {@link EdgeTypeName} to access the name counterpart.
+ * The actual value is represented as a bitmask, so please refer to {@link DfEdge} for helpful functions.
  */
 var EdgeType;
 (function (EdgeType) {
@@ -51,72 +45,84 @@ const edgeTypeToHumanReadableName = new Map([
     [EdgeType.NonStandardEvaluation, "non-standard-evaluation" /* EdgeTypeName.NonStandardEvaluation */]
 ]);
 /**
- * Only use this function to retrieve a human-readable name if you know that it is a single bitmask.
- * Otherwise, use {@link edgeTypesToNames} which handles these cases.
+ * Helper Functions to work with {@link DfEdge} and {@link EdgeType}.
  */
-function edgeTypeToName(type) {
-    return edgeTypeToHumanReadableName.get(type);
-}
-/**
- * Takes joint edge types and splits them into their individual components.
- */
-function splitEdgeTypes(types) {
-    const split = [];
-    for (const bit of edgeTypeToHumanReadableName.keys()) {
-        if ((types & bit) !== 0) {
-            split.push(bit);
+exports.DfEdge = {
+    /**
+     * Takes joint edge types and returns their human-readable names.
+     */
+    typesToNames({ types }) {
+        const rTypes = new Set();
+        for (const [bit, name] of edgeTypeToHumanReadableName.entries()) {
+            if ((types & bit) !== 0) {
+                rTypes.add(name);
+            }
         }
-    }
-    return split;
-}
-/**
- * Takes joint edge types and returns their human-readable names.
- */
-function edgeTypesToNames(bits) {
-    const types = new Set();
-    for (const [bit, name] of edgeTypeToHumanReadableName.entries()) {
-        if ((bits & bit) !== 0) {
-            types.add(name);
+        return rTypes;
+    },
+    /**
+     * Takes joint edge types and splits them into their individual components.
+     * @example
+     * ```ts
+     * DfEdge.splitTypes({ types: EdgeType.Reads | EdgeType.DefinedBy });
+     * // returns [EdgeType.Reads, EdgeType.DefinedBy]
+     * ```
+     */
+    splitTypes({ types }) {
+        const split = [];
+        for (const bit of edgeTypeToHumanReadableName.keys()) {
+            if ((types & bit) !== 0) {
+                split.push(bit);
+            }
         }
-    }
-    return types;
-}
-/**
- * Check if the given-edge type has any of the given types.
- * @example
- *
- * ```typescript
- * edgeIncludesType(EdgeType.Reads, EdgeType.Reads | EdgeType.DefinedBy) // true
- *```
- *
- * Counterpart of {@link edgeDoesNotIncludeType}.
- */
-function edgeIncludesType(type, typesToInclude) {
-    return (typesToInclude & type) !== 0;
-}
-/**
- * Check if the given-edge type does not include the given type.
- * Counterpart of {@link edgeIncludesType}.
- */
-function edgeDoesNotIncludeType(type, types) {
-    return (types & type) === 0;
-}
+        return split;
+    },
+    /**
+     * Only use this function to retrieve a human-readable name if you know that it is a single bitmask.
+     * Otherwise, use {@link DfEdge#typesToNames} which handles these cases.
+     */
+    typeToName(type) {
+        return edgeTypeToHumanReadableName.get(type);
+    },
+    /**
+     * Check if the given-edge type has any of the given types.
+     * As types are bitmasks, you can combine multiple types with a bitwise OR (`|`).
+     * @example
+     *
+     * ```ts
+     * edgeIncludesType({ types: EdgeType.Reads }, EdgeType.Reads | EdgeType.DefinedBy) // true
+     *```
+     *
+     * Counterpart of {@link DfEdge#doesNotIncludeType}.
+     */
+    includesType({ types }, typesToInclude) {
+        return (typesToInclude & types) !== 0;
+    },
+    /**
+     * Check if the given-edge type does not include the given type.
+     * As types are bitmasks, you can combine multiple types with a bitwise OR (`|`).
+     * Counterpart of {@link DfEdge#includesType}.
+     */
+    doesNotIncludeType({ types }, any) {
+        return (any & types) === 0;
+    },
+};
 const alwaysTraverseEdgeTypes = EdgeType.Reads | EdgeType.DefinedBy | EdgeType.Argument | EdgeType.Calls;
 const definedByOnCallTypes = EdgeType.DefinesOnCall | EdgeType.DefinedByOnCall;
 /**
  * Determines whether an edge should be traversed during dataflow analysis.
  */
-function shouldTraverseEdge(types) {
-    if (edgeIncludesType(types, EdgeType.NonStandardEvaluation)) {
+function shouldTraverseEdge(e) {
+    if (exports.DfEdge.includesType(e, EdgeType.NonStandardEvaluation)) {
         return 0 /* TraverseEdge.Never */;
     }
-    else if (edgeIncludesType(types, alwaysTraverseEdgeTypes)) {
+    else if (exports.DfEdge.includesType(e, alwaysTraverseEdgeTypes)) {
         return 3 /* TraverseEdge.Always */;
     }
-    else if (edgeIncludesType(types, definedByOnCallTypes)) {
+    else if (exports.DfEdge.includesType(e, definedByOnCallTypes)) {
         return 2 /* TraverseEdge.OnlyIfBoth */;
     }
-    else if (edgeIncludesType(types, EdgeType.SideEffectOnCall)) {
+    else if (exports.DfEdge.includesType(e, EdgeType.SideEffectOnCall)) {
         return 1 /* TraverseEdge.SideEffect */;
     }
     return 0 /* TraverseEdge.Never */;

package/dataflow/graph/graph.d.ts

@@ -1,8 +1,8 @@
-import type { DataflowGraphEdge, EdgeType } from './edge';
+import type { DfEdge, EdgeType } from './edge';
 import type { DataflowInformation } from '../info';
 import { type DataflowGraphVertexArgument, type DataflowGraphVertexFunctionCall, type DataflowGraphVertexInfo } from './vertex';
 import { EmptyArgument } from '../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
-import type { Identifier, IdentifierDefinition, IdentifierReference } from '../environments/identifier';
+import type { BrandedIdentifier, IdentifierDefinition, IdentifierReference } 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 { AstIdMap } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
@@ -55,19 +55,19 @@ export declare function getReferenceOfArgument(arg: FunctionArgument): NodeId |
 /**
  * Maps the edges target to the edge information
  */
-export type OutgoingEdges<Edge extends DataflowGraphEdge = DataflowGraphEdge> = Map<NodeId, Edge>;
+export type OutgoingEdges<Edge extends DfEdge = DfEdge> = Map<NodeId, Edge>;
 /**
  * Similar to {@link OutgoingEdges}, but inverted regarding the edge direction.
  * In other words, it maps the source to the edge information.
  */
-export type IngoingEdges<Edge extends DataflowGraphEdge = DataflowGraphEdge> = Map<NodeId, Edge>;
+export type IngoingEdges<Edge extends DfEdge = DfEdge> = Map<NodeId, Edge>;
 /**
  * The structure of the serialized {@link DataflowGraph}.
  */
 export interface DataflowGraphJson {
     readonly rootVertices: NodeId[];
     readonly vertexInformation: [NodeId, DataflowGraphVertexInfo][];
-    readonly edgeInformation: [NodeId, [NodeId, DataflowGraphEdge][]][];
+    readonly edgeInformation: [NodeId, [NodeId, DfEdge][]][];
     readonly _unknownSideEffects: UnknownSideEffect[];
 }
 /**
@@ -95,7 +95,7 @@ export type UnknownSideEffect = NodeId | {
  * @see {@link DataflowGraph#fromJson|`fromJson`} - to construct a dataflow graph object from a deserialized JSON object.
  * @see {@link emptyGraph|`emptyGraph`} - to create an empty graph (useful in tests)
  */
-export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = DataflowGraphVertexInfo, Edge extends DataflowGraphEdge = DataflowGraphEdge> {
+export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = DataflowGraphVertexInfo, Edge extends DfEdge = DfEdge> {
     private _idMap;
     private readonly _unknownSideEffects;
     constructor(idMap: AstIdMap | undefined);
@@ -219,6 +219,6 @@ export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = Data
 export interface IEnvironmentJson {
     readonly id: number;
     parent: IEnvironmentJson;
-    memory: Record<Identifier, IdentifierDefinition[]>;
+    memory: Record<BrandedIdentifier, IdentifierDefinition[]>;
     builtInEnv: true | undefined;
 }

package/dataflow/graph/quads.js

@@ -19,7 +19,7 @@ function df2quads(graph, config) {
         edges: graph.edges().flatMap(([fromId, targets]) => [...targets].map(([toId, info]) => ({
             from: fromId,
             to: toId,
-            type: [...(0, edge_1.edgeTypesToNames)(info.types)],
+            type: Array.from(edge_1.DfEdge.typesToNames(info)),
         }))).toArray()
     }, config);
 }

package/dataflow/graph/resolve-graph.js

@@ -41,7 +41,7 @@ function resolveDataflowGraph(graph, ctx, idMap) {
     /* recreate edges */
     for (const [from, targets] of graph.edges()) {
         for (const [to, info] of targets) {
-            for (const type of (0, edge_1.splitEdgeTypes)(info.types)) {
+            for (const type of edge_1.DfEdge.splitTypes(info)) {
                 resultGraph.addEdge(resolve(from), resolve(to), type);
             }
         }

package/dataflow/graph/unknown-replacement.d.ts

@@ -1,7 +1,8 @@
 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';
 export type ReplacementOperatorHandlerArgs = {
-    operator: string;
+    operator: Identifier;
     target: string | undefined;
     env: REnvironmentInformation;
     id: NodeId;

package/dataflow/graph/vertex.d.ts

@@ -4,6 +4,7 @@ import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-i
 import type { REnvironmentInformation } from '../environments/environment';
 import type { ControlDependency, ExitPoint } from '../info';
 import type { BuiltInProcName } from '../environments/built-in';
+import type { Identifier } from '../environments/identifier';
 export declare enum VertexType {
     Value = "value",
     Use = "use",
@@ -15,104 +16,6 @@ export declare const ValidVertexTypes: Set<string>;
 export declare const ValidVertexTypeReverse: {
     [k: string]: string;
 };
-/**
- * Identifier for arguments e.g. for `3` in `c(2, 3, 5)` the identifier would be
- * ```ts
- * {
- *   index: 2
- * }
- * ```
- */
-export interface UnnamedArgumentId {
-    readonly index: number;
-}
-/**
- * Identifier for named arguments e.g. for `age` in `list(name = 'John', age = 8)`
- * the indentifier would be
- * ```ts
- * {
- *   index: 2,
- *   lexeme: 'age'
- * }
- * ```
- */
-export interface NamedArgumentId {
-    /**
-     * Index may be undefined, when no index information is available.
-     */
-    readonly index: number | undefined;
-    readonly lexeme: string;
-}
-/**
- * Type guard to check whether {@link identifier} is a {@link NamedArgumentId}.
- */
-export declare function isNamedArgumentId(identifier: IndexIdentifier): identifier is NamedArgumentId;
-export type IndexIdentifier = UnnamedArgumentId | NamedArgumentId;
-/**
- * A single index of a container, which is not a container itself.
- *
- * This can be e.g. a string, number or boolean index.
- */
-export interface ContainerLeafIndex {
-    /**
-     * Distinctive identifier of index, see {@link IndexIdentifier}.
-     */
-    readonly identifier: IndexIdentifier;
-    /**
-     * NodeId of index in graph.
-     */
-    readonly nodeId: NodeId;
-}
-/**
- * A single index of a container, which is a container itself.
- *
- * This can be, e.g., a list, vector, or data frame.
- * @see {@link ContainerLeafIndex} - for a single index of a container which is not a container itself
- * @see {@link isParentContainerIndex} - to check if an index is a parent container index
- */
-export interface ContainerParentIndex extends ContainerLeafIndex {
-    /**
-     * Sub-indices of index.
-     */
-    readonly subIndices: ContainerIndices[];
-}
-/**
- * Type guard to check whether {@link index} is a {@link ContainerParentIndex}.
- */
-export declare function isParentContainerIndex(index: ContainerIndex): index is ContainerParentIndex;
-/**
- * A single index of a container.
- */
-export type ContainerIndex = ContainerLeafIndex | ContainerParentIndex;
-/**
- * Checks whether {@link index} is accessed by {@link accessLexeme}.
- * @param index - The {@link ContainerIndex}, which is accessed
- * @param accessLexeme - The access lexeme
- * @param isIndexBasedAccess - Whether the index of the {@link ContainerIndex} is accessed i.e. the position in the container and not e.g. the name of the index
- * @returns true, when {@link accessLexeme} accesses the {@link index}, false otherwise
- */
-export declare function isAccessed(index: ContainerIndex, accessLexeme: string, isIndexBasedAccess: boolean): boolean;
-/**
- * Checks whether two {@link ContainerIndex|container indices} are the same.
- */
-export declare function isSameIndex(a: ContainerIndex, b: ContainerIndex): boolean;
-/**
- * List of indices of a single statement like `list(a=3, b=2)`
- */
-export interface ContainerIndices {
-    readonly indices: ContainerIndex[];
-    /**
-     * Differentiate between single and multiple indices.
-     *
-     * For `list(name = 'John')` `isContainer` would be true, because a list may define more than one index.
-     * `isContainer` is true for e.g. single index assignments like `person$name <- 'John'`.
-     */
-    readonly isContainer: boolean;
-}
-/**
- * Collection of Indices of several statements.
- */
-export type ContainerIndicesCollection = ContainerIndices[] | undefined;
 /**
  * Arguments required to construct a vertex in the {@link DataflowGraph|dataflow graph}.
  * @see DataflowGraphVertexUse
@@ -138,10 +41,6 @@ interface DataflowGraphVertexBase extends MergeableRecord {
      * @see {@link ControlDependency} - the collection of control dependencies which have an influence on whether the vertex is executed.
      */
     cds: ControlDependency[] | undefined;
-    /**
-     * this attribute links a vertex to indices (pointer links) it may be affected by or related to
-     */
-    indicesCollection?: ContainerIndicesCollection;
     /**
      * Describes the collection of AST vertices that contributed to this vertex.
      * For example, this is useful with replacement operators, telling you which assignment operator caused them
@@ -198,7 +97,7 @@ export interface DataflowGraphVertexFunctionCall extends DataflowGraphVertexBase
      * For example, if the function is a replacement function, in this case, the actually called fn will
      * have the compound name (e.g., `[<-`).
      */
-    readonly name: string;
+    readonly name: Identifier;
     /** The arguments of the function call, in order (as they are passed to the respective call if executed in R). */
     args: FunctionArgument[];
     /** a performance flag to indicate that the respective call is _only_ calling a builtin function without any df graph attached */

package/dataflow/graph/vertex.js

@@ -1,10 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValidVertexTypeReverse = exports.ValidVertexTypes = exports.VertexType = void 0;
-exports.isNamedArgumentId = isNamedArgumentId;
-exports.isParentContainerIndex = isParentContainerIndex;
-exports.isAccessed = isAccessed;
-exports.isSameIndex = isSameIndex;
 exports.isValueVertex = isValueVertex;
 exports.isUseVertex = isUseVertex;
 exports.isFunctionCallVertex = isFunctionCallVertex;
@@ -20,46 +16,6 @@ var VertexType;
 })(VertexType || (exports.VertexType = VertexType = {}));
 exports.ValidVertexTypes = new Set(Object.values(VertexType));
 exports.ValidVertexTypeReverse = Object.fromEntries(Object.entries(VertexType).map(([k, v]) => [v, k]));
-/**
- * Type guard to check whether {@link identifier} is a {@link NamedArgumentId}.
- */
-function isNamedArgumentId(identifier) {
-    return 'lexeme' in identifier;
-}
-/**
- * Type guard to check whether {@link index} is a {@link ContainerParentIndex}.
- */
-function isParentContainerIndex(index) {
-    return 'subIndices' in index;
-}
-/**
- * Checks whether {@link index} is accessed by {@link accessLexeme}.
- * @param index - The {@link ContainerIndex}, which is accessed
- * @param accessLexeme - The access lexeme
- * @param isIndexBasedAccess - Whether the index of the {@link ContainerIndex} is accessed i.e. the position in the container and not e.g. the name of the index
- * @returns true, when {@link accessLexeme} accesses the {@link index}, false otherwise
- */
-function isAccessed(index, accessLexeme, isIndexBasedAccess) {
-    if (isIndexBasedAccess) {
-        return index.identifier.index === Number(accessLexeme);
-    }
-    if (isNamedArgumentId(index.identifier)) {
-        return index.identifier.lexeme === accessLexeme;
-    }
-    return false;
-}
-/**
- * Checks whether two {@link ContainerIndex|container indices} are the same.
- */
-function isSameIndex(a, b) {
-    if (isNamedArgumentId(a.identifier) && isNamedArgumentId(b.identifier)) {
-        return a.identifier.lexeme === b.identifier.lexeme;
-    }
-    if (a.identifier.index === undefined || b.identifier.index === undefined) {
-        return false;
-    }
-    return a.identifier.index === b.identifier.index;
-}
 /**
  * Check if the given vertex is a {@link DataflowGraphVertexValue|value vertex}.
  */

package/dataflow/internal/linker.d.ts

@@ -1,6 +1,6 @@
 import { DefaultMap } from '../../util/collections/defaultmap';
 import { type NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
-import { type IdentifierReference } from '../environments/identifier';
+import { Identifier, type IdentifierReference } from '../environments/identifier';
 import { type DataflowGraph, type FunctionArgument } from '../graph/graph';
 import type { RParameter } from '../../r-bridge/lang-4.x/ast/model/nodes/r-parameter';
 import type { AstIdMap, ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
@@ -8,7 +8,7 @@ import { type DataflowGraphVertexFunctionCall, type DataflowGraphVertexFunctionD
 import { type BuiltIn } from '../environments/built-in';
 import type { REnvironmentInformation } from '../environments/environment';
 import type { ExitPoint } from '../info';
-export type NameIdMap = DefaultMap<string, IdentifierReference[]>;
+export type NameIdMap = DefaultMap<Identifier, IdentifierReference[]>;
 /**
  * Find all reads within the graph that do not reference a local definition in the graph.
  */