@eagleoutice/flowr 2.8.15 → 2.9.0

package/util/mermaid/dfg.js

@@ -131,7 +131,7 @@ function mermaidNodeBrackets(tag) {
  * Prints an identifier definition in a human-readable format.
  */
 function printIdentifier(id) {
-    return `**${id.name}** (id: ${id.nodeId}, type: ${identifier_1.ReferenceTypeReverseMapping.get(id.type)},${id.cds ? ' cds: {' + id.cds.map(c => c.id + (c.when ? '+' : '-')).join(',') + '},' : ''} def. @${id.definedAt})`;
+    return `**${id.name ? identifier_1.Identifier.toString(id.name) : 'undefined'}** (id: ${id.nodeId}, type: ${identifier_1.ReferenceTypeReverseMapping.get(id.type)},${id.cds ? ' cds: {' + id.cds.map(c => c.id + (c.when ? '+' : '-')).join(',') + '},' : ''} def. @${id.definedAt})`;
 }
 function printEnvironmentToLines(env) {
     if (env === undefined) {
@@ -190,12 +190,12 @@ function vertexToMermaid(info, mermaid, id, idPrefix, mark, includeOnlyIds) {
         }
         const originalTarget = target;
         target = (0, mermaid_1.escapeId)(target);
-        const edgeTypes = typeof edge.types == 'number' ? new Set((0, edge_1.splitEdgeTypes)(edge.types)) : edge.types;
+        const edgeTypes = typeof edge.types == 'number' ? new Set(edge_1.DfEdge.splitTypes(edge)) : edge.types;
         const edgeId = encodeEdge(idPrefix + id, idPrefix + target, edgeTypes);
         if (!mermaid.presentEdges.has(edgeId)) {
             mermaid.presentEdges.add(edgeId);
             const style = (0, built_in_1.isBuiltIn)(target) ? '-.->' : '-->';
-            mermaid.edgeLines.push(`    ${idPrefix}${id} ${style}|"${[...edgeTypes].map(e => typeof e === 'number' ? (0, edge_1.edgeTypeToName)(e) : e).join(', ')}"| ${idPrefix}${target}`);
+            mermaid.edgeLines.push(`    ${idPrefix}${id} ${style}|"${[...edgeTypes].map(e => typeof e === 'number' ? edge_1.DfEdge.typeToName(e) : e).join(', ')}"| ${idPrefix}${target}`);
             if (mermaid.mark?.has(id + '->' + target)) {
                 // who invented this syntax?!
                 mermaid.edgeLines.push(`    linkStyle ${mermaid.presentEdges.size - 1} ${mermaid.markStyle.edge}`);

package/util/simple-df/dfg-ascii.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dfgToAscii = dfgToAscii;
 const dagre_1 = require("dagre");
-const edge_1 = require("../../dataflow/graph/edge");
 const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
 const vertex_1 = require("../../dataflow/graph/vertex");
+const edge_1 = require("../../dataflow/graph/edge");
 function combineAscii(has, add) {
     if (has === ' ' || has === add) {
         return add;
@@ -97,12 +97,12 @@ function dfgToAscii(dfg) {
     let longestId = 0;
     for (const [from, edges] of dfg.edges()) {
         longestId = Math.max(longestId, String(from).length);
-        for (const [to, { types }] of edges) {
+        for (const [to, e] of edges) {
             if (!g.hasNode(String(from)) || !g.hasNode(String(to)) || edgesDone.has(`${to}-${from}`)) {
                 continue;
             }
             longestId = Math.max(longestId, String(to).length);
-            g.setEdge(String(from), String(to), (0, edge_1.edgeTypesToNames)(types));
+            g.setEdge(String(from), String(to), edge_1.DfEdge.typesToNames(e));
             edgesDone.add(`${from}-${to}`);
         }
     }
@@ -116,11 +116,11 @@ function dfgToAscii(dfg) {
     const edgeLines = [];
     // add all edges
     for (const [from, edges] of dfg.edges()) {
-        for (const [to, { types }] of edges) {
+        for (const [to, e] of edges) {
             if (!g.hasNode(String(from)) || !g.hasNode(String(to))) {
                 continue;
             }
-            edgeLines.push(`${from.toString().padStart(longestId, ' ')} -> ${to.toString().padStart(longestId, ' ')}: ${Array.from((0, edge_1.edgeTypesToNames)(types)).join(', ')}`);
+            edgeLines.push(`${from.toString().padStart(longestId, ' ')} -> ${to.toString().padStart(longestId, ' ')}: ${Array.from(edge_1.DfEdge.typesToNames(e)).join(', ')}`);
         }
     }
     // always merge two edgelines with padding

package/util/version.js

@@ -6,7 +6,7 @@ exports.printVersionInformation = printVersionInformation;
 const semver_1 = require("semver");
 const assert_1 = require("./assert");
 // this is automatically replaced with the current version by release-it
-const version = '2.8.15';
+const version = '2.9.0';
 /**
  * Retrieves the current flowR version as a new {@link SemVer} object.
  */

package/util/containers.d.ts

@@ -1,66 +0,0 @@
-import type { REnvironmentInformation } from '../dataflow/environments/environment';
-import type { Identifier } from '../dataflow/environments/identifier';
-import { type ContainerIndices, type ContainerIndicesCollection, type IndexIdentifier } from '../dataflow/graph/vertex';
-import type { RAccess } from '../r-bridge/lang-4.x/ast/model/nodes/r-access';
-import type { RArgument } from '../r-bridge/lang-4.x/ast/model/nodes/r-argument';
-import { type RFunctionArgument } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
-import type { ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
-/**
- * Returns the accessed and access argument of an access operation by filtering the operation arguments.
- */
-export declare function getAccessOperands<OtherInfo>(args: readonly RFunctionArgument<OtherInfo & ParentInformation>[]): {
-    accessedArg: RArgument<OtherInfo & ParentInformation> | undefined;
-    accessArg: RArgument<OtherInfo & ParentInformation> | undefined;
-};
-/**
- * Resolves the passed name within the passed environment and returns the indicesCollection of the resolved definitions.
- * @param name - Name to resolve
- * @param environment - Environment in which name is resolved
- * @returns The indicesCollection of the resolved definitions
- */
-export declare function resolveIndicesByName(name: Identifier, environment: REnvironmentInformation): ContainerIndices[] | undefined;
-/**
- * Resolves {@link accessedArg} in the {@link environment} and filters its indices according to {@link accessArg}.
- *
- * If no indices could be found that match the `accessArg`, the original indices are returned as overapproximation.
- * @param accessedArg        - The argument to resolve
- * @param accessArg          - The argument which is used to filter the indices
- * @param environment        - The environment in which {@link accessedArg} is resolved
- * @param isIndexBasedAccess - Whether the access is index-based (e.g. `x[1]`) or name-based (e.g. `x$name`)
- * @returns The filtered {@link ContainerIndicesCollection} of the resolved {@link accessedArg}
- */
-export declare function resolveSingleIndex(accessedArg: {
-    lexeme: string;
-}, accessArg: {
-    lexeme: string;
-}, environment: REnvironmentInformation, isIndexBasedAccess: boolean): ContainerIndicesCollection;
-/**
- * Filters the single indices of the {@link indicesCollection} according to the lexeme of the {@link accessArg}.
- * @param indicesCollection  - The {@link ContainerIndicesCollection} to filter
- * @param accessArg          - The argument which is used to filter {@link indicesCollection}
- * @param isIndexBasedAccess - Whether the access is index-based (e.g. `x[1]`) or name-based (e.g. `x$name`)
- * @returns The filtered copy of {@link indicesCollection}
- */
-export declare function filterIndices(indicesCollection: ContainerIndicesCollection, accessArg: {
-    lexeme: string;
-}, isIndexBasedAccess: boolean): ContainerIndicesCollection;
-/**
- * Constructs the definition of a nested access.
- *
- * Example:
- * ```r
- * person$credentials$username
- * ```
- * would result in a list with the index `credentials`, which has the subIndex `username`.
- * @param accessedArg         - The top level argument that is accessed
- * @param leafIndices         - The index at the end of the nested access i.e. `c` in `a$b$c`.
- * @param constructIdentifier - A function that constructs the identifier for the index from the argument
- * @returns The constructed nested access
- */
-export declare function constructNestedAccess<OtherInfo>(accessedArg: RAccess<OtherInfo & ParentInformation>, leafIndices: ContainerIndices, constructIdentifier: (arg: RArgument<OtherInfo & ParentInformation>) => IndexIdentifier): ContainerIndices[];
-/**
- * Adds the passed list of {@link leafSubIndices} to the leaf (sub-)indices of {@link indicesCollection}.
- * @param indicesCollection - Indices where to add the sub indices.
- * @param leafSubIndices    - Indices that are added to the leaf indices.
- */
-export declare function addSubIndicesToLeafIndices(indicesCollection: ContainerIndices[], leafSubIndices: ContainerIndices[]): ContainerIndices[];

package/util/containers.js

@@ -1,143 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAccessOperands = getAccessOperands;
-exports.resolveIndicesByName = resolveIndicesByName;
-exports.resolveSingleIndex = resolveSingleIndex;
-exports.filterIndices = filterIndices;
-exports.constructNestedAccess = constructNestedAccess;
-exports.addSubIndicesToLeafIndices = addSubIndicesToLeafIndices;
-const resolve_by_name_1 = require("../dataflow/environments/resolve-by-name");
-const vertex_1 = require("../dataflow/graph/vertex");
-const r_function_call_1 = require("../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
-const type_1 = require("../r-bridge/lang-4.x/ast/model/type");
-/**
- * Returns the accessed and access argument of an access operation by filtering the operation arguments.
- */
-function getAccessOperands(args) {
-    const nonEmptyArgs = args.filter(arg => arg !== r_function_call_1.EmptyArgument);
-    const accessedArg = nonEmptyArgs.find(arg => arg.info.role === "accessed" /* RoleInParent.Accessed */);
-    const accessArg = nonEmptyArgs.find(arg => arg.info.role === "index-acc" /* RoleInParent.IndexAccess */);
-    return { accessedArg, accessArg };
-}
-/**
- * Resolves the passed name within the passed environment and returns the indicesCollection of the resolved definitions.
- * @param name - Name to resolve
- * @param environment - Environment in which name is resolved
- * @returns The indicesCollection of the resolved definitions
- */
-function resolveIndicesByName(name, environment) {
-    const definitions = (0, resolve_by_name_1.resolveByNameAnyType)(name, environment);
-    return definitions?.flatMap(def => def?.indicesCollection ?? []);
-}
-/**
- * Resolves {@link accessedArg} in the {@link environment} and filters its indices according to {@link accessArg}.
- *
- * If no indices could be found that match the `accessArg`, the original indices are returned as overapproximation.
- * @param accessedArg        - The argument to resolve
- * @param accessArg          - The argument which is used to filter the indices
- * @param environment        - The environment in which {@link accessedArg} is resolved
- * @param isIndexBasedAccess - Whether the access is index-based (e.g. `x[1]`) or name-based (e.g. `x$name`)
- * @returns The filtered {@link ContainerIndicesCollection} of the resolved {@link accessedArg}
- */
-function resolveSingleIndex(accessedArg, accessArg, environment, isIndexBasedAccess) {
-    const indicesCollection = resolveIndicesByName(accessedArg.lexeme, environment);
-    const accessedIndicesCollection = filterIndices(indicesCollection, accessArg, isIndexBasedAccess);
-    // If the accessed indices couldn't be resolved, overapproximate by returning the original indices.
-    // This could also be the case, when nothing is acccessed, but we better be safe.
-    if (accessedIndicesCollection === undefined) {
-        return indicesCollection;
-    }
-    else {
-        return accessedIndicesCollection;
-    }
-}
-/**
- * Filters the single indices of the {@link indicesCollection} according to the lexeme of the {@link accessArg}.
- * @param indicesCollection  - The {@link ContainerIndicesCollection} to filter
- * @param accessArg          - The argument which is used to filter {@link indicesCollection}
- * @param isIndexBasedAccess - Whether the access is index-based (e.g. `x[1]`) or name-based (e.g. `x$name`)
- * @returns The filtered copy of {@link indicesCollection}
- */
-function filterIndices(indicesCollection, accessArg, isIndexBasedAccess) {
-    let accessedIndicesCollection = undefined;
-    for (const indices of indicesCollection ?? []) {
-        const filteredIndices = indices.indices.filter(index => (0, vertex_1.isAccessed)(index, accessArg.lexeme, isIndexBasedAccess));
-        if (filteredIndices.length === 0) {
-            continue;
-        }
-        accessedIndicesCollection ??= [];
-        accessedIndicesCollection.push({
-            indices: filteredIndices,
-            isContainer: indices.isContainer
-        });
-    }
-    return accessedIndicesCollection;
-}
-/**
- * Constructs the definition of a nested access.
- *
- * Example:
- * ```r
- * person$credentials$username
- * ```
- * would result in a list with the index `credentials`, which has the subIndex `username`.
- * @param accessedArg         - The top level argument that is accessed
- * @param leafIndices         - The index at the end of the nested access i.e. `c` in `a$b$c`.
- * @param constructIdentifier - A function that constructs the identifier for the index from the argument
- * @returns The constructed nested access
- */
-function constructNestedAccess(accessedArg, leafIndices, constructIdentifier) {
-    const accessed = accessedArg.accessed;
-    const accesses = accessedArg.access.filter(arg => arg !== r_function_call_1.EmptyArgument).map(arg => arg);
-    const indices = [];
-    for (const access of accesses) {
-        const newIndices = {
-            indices: [
-                {
-                    identifier: constructIdentifier(access),
-                    nodeId: access.info.id,
-                    subIndices: [leafIndices],
-                }
-            ],
-            isContainer: false,
-        };
-        if (accessed.type === type_1.RType.Access) {
-            const nestedIndices = constructNestedAccess(accessed, newIndices, constructIdentifier);
-            indices.push(...nestedIndices);
-        }
-        else {
-            indices.push(newIndices);
-        }
-    }
-    return indices;
-}
-/**
- * Adds the passed list of {@link leafSubIndices} to the leaf (sub-)indices of {@link indicesCollection}.
- * @param indicesCollection - Indices where to add the sub indices.
- * @param leafSubIndices    - Indices that are added to the leaf indices.
- */
-function addSubIndicesToLeafIndices(indicesCollection, leafSubIndices) {
-    const result = [];
-    for (const indices of indicesCollection) {
-        const newIndices = [];
-        for (const index of indices.indices) {
-            let newSubIndices = [];
-            if ((0, vertex_1.isParentContainerIndex)(index)) {
-                newSubIndices = addSubIndicesToLeafIndices(index.subIndices, leafSubIndices);
-            }
-            else {
-                newSubIndices = leafSubIndices;
-            }
-            newIndices.push({
-                ...index,
-                subIndices: newSubIndices,
-            });
-        }
-        result.push({
-            ...indices,
-            indices: newIndices,
-        });
-    }
-    return result;
-}
-//# sourceMappingURL=containers.js.map