@eagleoutice/flowr 2.7.0 → 2.7.2

package/util/mermaid/info.d.ts

@@ -0,0 +1,17 @@
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+type MarkVertex = NodeId;
+type MarkEdge = `${string}->${string}`;
+export type MermaidMarkdownMark = MarkVertex | MarkEdge;
+export interface MermaidMarkStyle {
+    readonly vertex: string;
+    readonly edge: string;
+}
+export interface MermaidGraphPrinterInfo {
+    includeOnlyIds?: ReadonlySet<NodeId>;
+    mark?: ReadonlySet<MermaidMarkdownMark>;
+    markStyle?: MermaidMarkStyle;
+    prefix?: string;
+    simplify?: boolean;
+}
+export declare const MermaidDefaultMarkStyle: MermaidMarkStyle;
+export {};

package/util/mermaid/info.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MermaidDefaultMarkStyle = void 0;
+exports.MermaidDefaultMarkStyle = { vertex: 'stroke:teal,stroke-width:7px,stroke-opacity:.8;', edge: 'stroke:teal,stroke-width:4.2px,stroke-opacity:.8' };
+//# sourceMappingURL=info.js.map

package/util/prefix.d.ts

@@ -1,12 +1,16 @@
 /**
- * given a potentially partial prefix like `hell`, this finds the matching name in the map, but only
+ * Given a potentially partial prefix like `hell`, this finds the matching name in the keys, but only
  * if it is unique!
+ * Please note, that `...` is considered special here, anything *afteR* `...` will not be matched by prefix but only by exact name,
+ * following R's pmatch semantics.
  * @example
  * ```typescript
- * findByPrefixIfUnique('hell', { 'hello', 'bar' }) // => 'hello'
- * findByPrefixIfUnique('hell', { 'hello', 'hell' }) // => 'hell' (full match)
- * findByPrefixIfUnique('h', { 'hello', 'hell' }) // => undefined (not unique)
- * findByPrefixIfUnique('', { 'hello', 'hell' }) // => undefined (empty prefix)
+ * findByPrefixIfUnique('hello', [ 'hello', 'bar' ]) // => 'hello'
+ * findByPrefixIfUnique('hell', [ 'hello', 'bar' ]) // => 'hello'
+ * findByPrefixIfUnique('hell', [ 'hello', 'hell' ]) // => 'hell' (full/exact match)
+ * findByPrefixIfUnique('hell', [ 'bar', '...', 'hello' ]) // => undefined (not matched due to being after `...`)
+ * findByPrefixIfUnique('h', [ 'hello', 'hell' ]) // => undefined (not unique)
+ * findByPrefixIfUnique('', [ 'hello', 'hell' ]) // => undefined (empty prefix)
  * ```
  */
 export declare function findByPrefixIfUnique(prefix: string, keys: readonly string[] | MapIterator<string>): string | undefined;

package/util/prefix.js

@@ -2,14 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findByPrefixIfUnique = findByPrefixIfUnique;
 /**
- * given a potentially partial prefix like `hell`, this finds the matching name in the map, but only
+ * Given a potentially partial prefix like `hell`, this finds the matching name in the keys, but only
  * if it is unique!
+ * Please note, that `...` is considered special here, anything *afteR* `...` will not be matched by prefix but only by exact name,
+ * following R's pmatch semantics.
  * @example
  * ```typescript
- * findByPrefixIfUnique('hell', { 'hello', 'bar' }) // => 'hello'
- * findByPrefixIfUnique('hell', { 'hello', 'hell' }) // => 'hell' (full match)
- * findByPrefixIfUnique('h', { 'hello', 'hell' }) // => undefined (not unique)
- * findByPrefixIfUnique('', { 'hello', 'hell' }) // => undefined (empty prefix)
+ * findByPrefixIfUnique('hello', [ 'hello', 'bar' ]) // => 'hello'
+ * findByPrefixIfUnique('hell', [ 'hello', 'bar' ]) // => 'hello'
+ * findByPrefixIfUnique('hell', [ 'hello', 'hell' ]) // => 'hell' (full/exact match)
+ * findByPrefixIfUnique('hell', [ 'bar', '...', 'hello' ]) // => undefined (not matched due to being after `...`)
+ * findByPrefixIfUnique('h', [ 'hello', 'hell' ]) // => undefined (not unique)
+ * findByPrefixIfUnique('', [ 'hello', 'hell' ]) // => undefined (empty prefix)
  * ```
  */
 function findByPrefixIfUnique(prefix, keys) {
@@ -17,11 +21,15 @@ function findByPrefixIfUnique(prefix, keys) {
         return undefined;
     }
     let found = undefined;
+    let matchPartial = true;
     for (const key of keys) {
         if (key === prefix) {
             return key;
         }
-        if (key.startsWith(prefix)) {
+        if (key === '...') {
+            matchPartial = false;
+        }
+        else if (matchPartial && key.startsWith(prefix)) {
             if (found) {
                 return undefined;
             }

package/util/r-regex.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Represents R's `.standard_regexps` definitions.
+ * @see https://github.com/r-devel/r-svn/blob/44474af03ae77fd3b9a340279fa10cb698d106c3/src/library/base/R/utils.R#L52-L53
+ */
+export declare const RStandardRegexp: {
+    /** `[[:alpha:]][[:alnum:].]*[[:alnum:]]` */
+    ValidPackageName: RegExp;
+    /** `([[:digit:]]+[.-]){1,}[[:digit:]]+` */
+    ValidPackageVersion: RegExp;
+    /** `[[:digit:]]+\\.[[:digit:]]+\\.[[:digit:]]+` */
+    ValidRSystemVersion: RegExp;
+    /** `([[:digit:]]+[.-])*[[:digit:]]+` */
+    ValidNumericVersion: RegExp;
+};
+/**
+ * Based on the C-definition:
+ * ```txt
+ * !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
+ * ```
+ */
+export declare const RPunctuationChars = "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";

package/util/r-regex.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RPunctuationChars = exports.RStandardRegexp = void 0;
+/**
+ * Represents R's `.standard_regexps` definitions.
+ * @see https://github.com/r-devel/r-svn/blob/44474af03ae77fd3b9a340279fa10cb698d106c3/src/library/base/R/utils.R#L52-L53
+ */
+exports.RStandardRegexp = {
+    /** `[[:alpha:]][[:alnum:].]*[[:alnum:]]` */
+    ValidPackageName: (/[A-Za-z][A-Za-z0-9._]*[A-Za-z0-9]/),
+    /** `([[:digit:]]+[.-]){1,}[[:digit:]]+` */
+    ValidPackageVersion: (/([0-9]+[.-])+[0-9]+/),
+    /** `[[:digit:]]+\\.[[:digit:]]+\\.[[:digit:]]+` */
+    ValidRSystemVersion: (/[0-9]+\.[0-9]+\.[0-9]+/),
+    /** `([[:digit:]]+[.-])*[[:digit:]]+` */
+    ValidNumericVersion: /([0-9]+[.-])*[0-9]+/
+};
+/**
+ * Based on the C-definition:
+ * ```txt
+ * !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
+ * ```
+ */
+exports.RPunctuationChars = '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~';
+//# sourceMappingURL=r-regex.js.map

package/util/text/args.js

@@ -55,10 +55,19 @@ function splitAtEscapeSensitive(inputString, escapeQuote = true, split = ' ') {
             current = '';
         }
         else if (c === '"' || c === "'") {
-            inQuotes = !inQuotes;
-            if (!escapeQuote) {
-                current += c;
+            if (!inQuotes) {
+                inQuotes = c;
+                if (escapeQuote) {
+                    continue;
+                }
             }
+            else if (inQuotes === c) {
+                inQuotes = false;
+                if (escapeQuote) {
+                    continue;
+                }
+            }
+            current += c;
         }
         else if (c === '\\' && escapeQuote) {
             escaped = true;

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.7.0';
+const version = '2.7.2';
 /**
  * Retrieves the current flowR version as a new {@link SemVer} object.
  */

package/abstract-interpretation/data-frame/absint-info.d.ts

@@ -1,109 +0,0 @@
-import type { RNode } from '../../r-bridge/lang-4.x/ast/model/model';
-import type { ParentInformation } 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 { DataFrameStateDomain } from './dataframe-domain';
-import type { ConstraintType, DataFrameOperationArgs, DataFrameOperationName, DataFrameOperationOptions } from './semantics';
-/**
- * An abstract data frame operation without additional options.
- * - `operation` contains the type of the abstract operation (see {@link DataFrameOperationName})
- * - `operand` contains the ID of the data frame operand of the operation (may be `undefined`)
- * - `...args` contains the arguments of the abstract operation (see {@link DataFrameOperationArgs})
- */
-export type DataFrameOperationType<OperationName extends DataFrameOperationName = DataFrameOperationName> = {
-    [Name in OperationName]: {
-        operation: Name;
-        operand: NodeId | undefined;
-    } & DataFrameOperationArgs<Name>;
-}[OperationName];
-/**
- * An abstract data frame operation.
- * - `operation` contains the type of the abstract operation (see {@link DataFrameOperationName})
- * - `operand` contains the ID of the data frame operand of the operation (may be `undefined`)
- * - `type` optionally contains the constraint type to overwrite the default type of the operation (see {@link ConstraintType})
- * - `options` optionally contains additional options for the abstract operation (see {@link DataFrameOperationOptions})
- * - `...args` contains the arguments of the abstract operation (see {@link DataFrameOperationArgs})
- */
-export type DataFrameOperation<OperationName extends DataFrameOperationName = DataFrameOperationName> = {
-    [Name in OperationName]: {
-        operation: Name;
-        operand: NodeId | undefined;
-        type?: ConstraintType;
-        options?: DataFrameOperationOptions<Name>;
-    } & DataFrameOperationArgs<Name>;
-}[OperationName];
-/**
- * Represents the base data frame information stored in the abstract interpretation info of an AST node.
- * - `type` optionally defines the type of the extra information stored in the data frame info
- * - `domain` contains the abstract data frame shape state of the node
- *   This may not be present if the data frame shape inference has not been executed yet or the program contains no data frames
- */
-interface DataFrameInfoBase {
-    type?: string;
-    domain?: DataFrameStateDomain;
-}
-/** Enum to mark nodes during the data frame shape inference */
-export declare enum DataFrameInfoMarker {
-    /** Marks the target symbol of assignments as "unassigned" until the assigned expression is evaluated */
-    Unassigned = "unassigned"
-}
-/**
- * Represents the data frame information for a node without extra data frame information,
- * i.e. for all nodes that do not represent a data frame assignment or data frame operation (this is the default).
- *
- * The `marker` can be used to mark nodes during the data frame shape inference.
- */
-interface DataFrameEmptyInfo extends DataFrameInfoBase {
-    type?: never;
-    marker?: DataFrameInfoMarker;
-}
-/**
- * Represents the data frame information for a data frame assignment with a target identifier (symbol/string) and an assigned expression.
- * This is used during data frame shape inference to mark assignments of data frame expressions to an identifier.
- *
- * Use {@link hasDataFrameAssignmentInfo} to check whether an AST node has attached data frame assignment information.
- */
-export interface DataFrameAssignmentInfo extends DataFrameInfoBase {
-    type: 'assignment';
-    identifier: NodeId;
-    expression: NodeId;
-}
-/**
- * Represents the data frame information for a data frame function/operation with mapped abstract operations.
- * This is used during data frame shape inference to store the abstract operations a data frame function/operation is mapped to.
- *
- * The order of the abstract operations is the order in which their semantics are applied (for example, access operations are typically before other operations in the list).
- * Moreover, abstract operations that take the result of previous abstract operation as data frame operand must have the `operand` set to `undefined`.
- *
- * Use {@link hasDataFrameExpressionInfo} to check whether an AST node has attached data frame expression information.
- */
-export interface DataFrameExpressionInfo extends DataFrameInfoBase {
-    type: 'expression';
-    operations: DataFrameOperation[];
-}
-/**
- * Represents the data frame shape inference information stored in the abstract interpretation info of AST nodes.
- */
-export type DataFrameInfo = DataFrameEmptyInfo | DataFrameAssignmentInfo | DataFrameExpressionInfo;
-/**
- * Represents the abstract interpretation information attached to AST nodes.
- */
-export interface AbstractInterpretationInfo {
-    dataFrame?: DataFrameInfo;
-}
-/**
- * Checks whether an AST node has attached data frame assignment information.
- */
-export declare function hasDataFrameAssignmentInfo<OtherInfo>(node: RNode<OtherInfo & ParentInformation & AbstractInterpretationInfo>): node is RNode<OtherInfo & ParentInformation & AbstractInterpretationInfo & {
-    dataFrame: DataFrameAssignmentInfo;
-}>;
-/**
- * Checks whether an AST node has attached data frame expression information.
- */
-export declare function hasDataFrameExpressionInfo<OtherInfo>(node: RNode<OtherInfo & ParentInformation & AbstractInterpretationInfo>): node is RNode<OtherInfo & ParentInformation & AbstractInterpretationInfo & {
-    dataFrame: DataFrameExpressionInfo;
-}>;
-/**
- * Checks whether an AST node has an attached data frame info marker.
- */
-export declare function hasDataFrameInfoMarker<OtherInfo>(node: RNode<OtherInfo & ParentInformation & AbstractInterpretationInfo>, marker: DataFrameInfoMarker): boolean;
-export {};

package/abstract-interpretation/data-frame/absint-info.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataFrameInfoMarker = void 0;
-exports.hasDataFrameAssignmentInfo = hasDataFrameAssignmentInfo;
-exports.hasDataFrameExpressionInfo = hasDataFrameExpressionInfo;
-exports.hasDataFrameInfoMarker = hasDataFrameInfoMarker;
-/** Enum to mark nodes during the data frame shape inference */
-var DataFrameInfoMarker;
-(function (DataFrameInfoMarker) {
-    /** Marks the target symbol of assignments as "unassigned" until the assigned expression is evaluated */
-    DataFrameInfoMarker["Unassigned"] = "unassigned";
-})(DataFrameInfoMarker || (exports.DataFrameInfoMarker = DataFrameInfoMarker = {}));
-/**
- * Checks whether an AST node has attached data frame assignment information.
- */
-function hasDataFrameAssignmentInfo(node) {
-    return node.info.dataFrame?.type === 'assignment';
-}
-/**
- * Checks whether an AST node has attached data frame expression information.
- */
-function hasDataFrameExpressionInfo(node) {
-    return node.info.dataFrame?.type === 'expression';
-}
-/**
- * Checks whether an AST node has an attached data frame info marker.
- */
-function hasDataFrameInfoMarker(node, marker) {
-    return node.info.dataFrame?.type === undefined && node.info.dataFrame?.marker === marker;
-}
-//# sourceMappingURL=absint-info.js.map

package/abstract-interpretation/data-frame/absint-visitor.d.ts

@@ -1,57 +0,0 @@
-import { type CfgBasicBlockVertex, type CfgSimpleVertex, type ControlFlowInformation } from '../../control-flow/control-flow-graph';
-import { SemanticCfgGuidedVisitor, type SemanticCfgGuidedVisitorConfiguration } from '../../control-flow/semantic-cfg-guided-visitor';
-import type { DataflowGraph } from '../../dataflow/graph/graph';
-import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexVariableDefinition } from '../../dataflow/graph/vertex';
-import type { NoInfo } from '../../r-bridge/lang-4.x/ast/model/model';
-import type { NormalizedAst } 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 AbstractInterpretationInfo } from './absint-info';
-export type DataFrameShapeInferenceVisitorConfiguration<OtherInfo = NoInfo, ControlFlow extends ControlFlowInformation = ControlFlowInformation, Ast extends NormalizedAst<OtherInfo & AbstractInterpretationInfo> = NormalizedAst<OtherInfo & AbstractInterpretationInfo>, Dfg extends DataflowGraph = DataflowGraph> = Omit<SemanticCfgGuidedVisitorConfiguration<OtherInfo & AbstractInterpretationInfo, ControlFlow, Ast, Dfg>, 'defaultVisitingOrder' | 'defaultVisitingType'>;
-/**
- * The control flow graph visitor to infer the shape of data frames using abstract interpretation
- */
-export declare class DataFrameShapeInferenceVisitor<OtherInfo = NoInfo, ControlFlow extends ControlFlowInformation = ControlFlowInformation, Ast extends NormalizedAst<OtherInfo & AbstractInterpretationInfo> = NormalizedAst<OtherInfo & AbstractInterpretationInfo>, Dfg extends DataflowGraph = DataflowGraph, Config extends DataFrameShapeInferenceVisitorConfiguration<OtherInfo, ControlFlow, Ast, Dfg> = DataFrameShapeInferenceVisitorConfiguration<OtherInfo, ControlFlow, Ast, Dfg>> extends SemanticCfgGuidedVisitor<OtherInfo & AbstractInterpretationInfo, ControlFlow, Ast, Dfg, Config & {
-    defaultVisitingOrder: 'forward';
-    defaultVisitingType: 'exit';
-}> {
-    /**
-     * The old domain of an AST node before processing the node retrieved from the attached {@link AbstractInterpretationInfo}.
-     * This is used to check whether the state has changed and successors should be visited again, and is also required for widening.
-     */
-    private oldDomain;
-    /**
-     * The new domain of an AST node during and after processing the node.
-     * This information is stored in the {@link AbstractInterpretationInfo} afterward.
-     */
-    private newDomain;
-    constructor(config: Config);
-    protected visitNode(nodeId: NodeId): boolean;
-    protected visitDataflowNode(vertex: Exclude<CfgSimpleVertex, CfgBasicBlockVertex>): void;
-    protected onVariableDefinition({ vertex }: {
-        vertex: DataflowGraphVertexVariableDefinition;
-    }): void;
-    protected onAssignmentCall({ call, target, source }: {
-        call: DataflowGraphVertexFunctionCall;
-        target?: NodeId;
-        source?: NodeId;
-    }): void;
-    protected onAccessCall({ call }: {
-        call: DataflowGraphVertexFunctionCall;
-    }): void;
-    protected onDefaultFunctionCall({ call }: {
-        call: DataflowGraphVertexFunctionCall;
-    }): void;
-    protected onReplacementCall({ call, source, target }: {
-        call: DataflowGraphVertexFunctionCall;
-        source: NodeId | undefined;
-        target: NodeId | undefined;
-    }): void;
-    private applyDataFrameAssignment;
-    private applyDataFrameExpression;
-    /** We only process vertices of leaf nodes and exit vertices (no entry nodes of complex nodes) */
-    private shouldSkipVertex;
-    /** Get all AST nodes for the predecessor vertices that are leaf nodes and exit vertices */
-    private getPredecessorNodes;
-    private shouldWiden;
-    private clearUnassignedInfo;
-}

package/abstract-interpretation/data-frame/absint-visitor.js

@@ -1,176 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataFrameShapeInferenceVisitor = void 0;
-const control_flow_graph_1 = require("../../control-flow/control-flow-graph");
-const semantic_cfg_guided_visitor_1 = require("../../control-flow/semantic-cfg-guided-visitor");
-const assert_1 = require("../../util/assert");
-const absint_info_1 = require("./absint-info");
-const dataframe_domain_1 = require("./dataframe-domain");
-const access_mapper_1 = require("./mappers/access-mapper");
-const assignment_mapper_1 = require("./mappers/assignment-mapper");
-const function_mapper_1 = require("./mappers/function-mapper");
-const replacement_mapper_1 = require("./mappers/replacement-mapper");
-const semantics_1 = require("./semantics");
-const shape_inference_1 = require("./shape-inference");
-/**
- * The control flow graph visitor to infer the shape of data frames using abstract interpretation
- */
-class DataFrameShapeInferenceVisitor extends semantic_cfg_guided_visitor_1.SemanticCfgGuidedVisitor {
-    /**
-     * The old domain of an AST node before processing the node retrieved from the attached {@link AbstractInterpretationInfo}.
-     * This is used to check whether the state has changed and successors should be visited again, and is also required for widening.
-     */
-    oldDomain = dataframe_domain_1.DataFrameStateDomain.bottom();
-    /**
-     * The new domain of an AST node during and after processing the node.
-     * This information is stored in the {@link AbstractInterpretationInfo} afterward.
-     */
-    newDomain = dataframe_domain_1.DataFrameStateDomain.bottom();
-    constructor(config) {
-        super({ ...config, defaultVisitingOrder: 'forward', defaultVisitingType: 'exit' });
-    }
-    visitNode(nodeId) {
-        const vertex = this.getCfgVertex(nodeId);
-        // skip vertices representing entries of complex nodes
-        if (vertex === undefined || this.shouldSkipVertex(vertex)) {
-            return true;
-        }
-        const predecessors = this.getPredecessorNodes(vertex.id);
-        const predecessorDomains = predecessors.map(node => node.info.dataFrame?.domain).filter(assert_1.isNotUndefined);
-        this.newDomain = dataframe_domain_1.DataFrameStateDomain.bottom().joinAll(predecessorDomains);
-        this.onVisitNode(nodeId);
-        const visitedCount = this.visited.get(vertex.id) ?? 0;
-        this.visited.set(vertex.id, visitedCount + 1);
-        // only continue visiting if the node has not been visited before or the data frame value of the node changed
-        return visitedCount === 0 || !this.oldDomain.equals(this.newDomain);
-    }
-    visitDataflowNode(vertex) {
-        const node = this.getNormalizedAst((0, control_flow_graph_1.getVertexRootId)(vertex));
-        if (node === undefined) {
-            return;
-        }
-        this.oldDomain = node.info.dataFrame?.domain ?? dataframe_domain_1.DataFrameStateDomain.bottom();
-        super.visitDataflowNode(vertex);
-        if (this.config.dfg.unknownSideEffects.has((0, control_flow_graph_1.getVertexRootId)(vertex))) {
-            this.newDomain = this.newDomain.bottom();
-        }
-        if (this.shouldWiden(vertex)) {
-            this.newDomain = this.oldDomain.widen(this.newDomain);
-        }
-        node.info.dataFrame ??= {};
-        node.info.dataFrame.domain = this.newDomain;
-    }
-    onVariableDefinition({ vertex }) {
-        const node = this.getNormalizedAst(vertex.id);
-        if (node !== undefined) {
-            // mark variable definitions as "unassigned", as the evaluation of the assigned expression is delayed until processing the assignment
-            node.info.dataFrame ??= { marker: absint_info_1.DataFrameInfoMarker.Unassigned };
-        }
-    }
-    onAssignmentCall({ call, target, source }) {
-        const node = this.getNormalizedAst(call.id);
-        const targetNode = this.getNormalizedAst(target);
-        const sourceNode = this.getNormalizedAst(source);
-        if (node !== undefined && (0, assignment_mapper_1.isAssignmentTarget)(targetNode) && sourceNode !== undefined) {
-            node.info.dataFrame = (0, assignment_mapper_1.mapDataFrameVariableAssignment)(targetNode, sourceNode, this.config.dfg, this.config.ctx);
-            this.applyDataFrameAssignment(node);
-            this.clearUnassignedInfo(targetNode);
-        }
-    }
-    onAccessCall({ call }) {
-        const node = this.getNormalizedAst(call.id);
-        if (node !== undefined) {
-            node.info.dataFrame = (0, access_mapper_1.mapDataFrameAccess)(node, this.config.dfg, this.config.ctx);
-            this.applyDataFrameExpression(node);
-        }
-    }
-    onDefaultFunctionCall({ call }) {
-        const node = this.getNormalizedAst(call.id);
-        if (node !== undefined) {
-            node.info.dataFrame = (0, function_mapper_1.mapDataFrameFunctionCall)(node, this.config.dfg, this.config.ctx);
-            this.applyDataFrameExpression(node);
-        }
-    }
-    onReplacementCall({ call, source, target }) {
-        const node = this.getNormalizedAst(call.id);
-        const targetNode = this.getNormalizedAst(target);
-        const sourceNode = this.getNormalizedAst(source);
-        if (node !== undefined && targetNode !== undefined && sourceNode !== undefined) {
-            node.info.dataFrame = (0, replacement_mapper_1.mapDataFrameReplacementFunction)(node, sourceNode, this.config.dfg, this.config.ctx);
-            this.applyDataFrameExpression(node);
-            this.clearUnassignedInfo(targetNode);
-        }
-    }
-    applyDataFrameAssignment(node) {
-        if (!(0, absint_info_1.hasDataFrameAssignmentInfo)(node)) {
-            return;
-        }
-        const value = (0, shape_inference_1.resolveIdToDataFrameShape)(node.info.dataFrame.expression, this.config.dfg, this.newDomain);
-        if (value !== undefined) {
-            this.newDomain.set(node.info.dataFrame.identifier, value);
-            const identifier = this.getNormalizedAst(node.info.dataFrame.identifier);
-            if (identifier !== undefined) {
-                identifier.info.dataFrame ??= {};
-                identifier.info.dataFrame.domain = this.newDomain.create(this.newDomain.value);
-            }
-        }
-    }
-    applyDataFrameExpression(node) {
-        if (!(0, absint_info_1.hasDataFrameExpressionInfo)(node)) {
-            return;
-        }
-        const maxColNames = this.config.ctx.config.abstractInterpretation.dataFrame.maxColNames;
-        let value = dataframe_domain_1.DataFrameDomain.top(maxColNames);
-        for (const { operation, operand, type, options, ...args } of node.info.dataFrame.operations) {
-            const operandValue = operand !== undefined ? (0, shape_inference_1.resolveIdToDataFrameShape)(operand, this.config.dfg, this.newDomain) : value;
-            value = (0, semantics_1.applyDataFrameSemantics)(operation, operandValue ?? dataframe_domain_1.DataFrameDomain.top(maxColNames), args, options);
-            const constraintType = type ?? (0, semantics_1.getConstraintType)(operation);
-            if (operand !== undefined && constraintType === semantics_1.ConstraintType.OperandModification) {
-                this.newDomain.set(operand, value);
-                for (const origin of (0, shape_inference_1.getVariableOrigins)(operand, this.config.dfg)) {
-                    this.newDomain.set(origin.info.id, value);
-                }
-            }
-            else if (constraintType === semantics_1.ConstraintType.ResultPostcondition) {
-                this.newDomain.set(node.info.id, value);
-            }
-        }
-    }
-    /** We only process vertices of leaf nodes and exit vertices (no entry nodes of complex nodes) */
-    shouldSkipVertex(vertex) {
-        return (0, control_flow_graph_1.isMarkerVertex)(vertex) ? vertex.type !== control_flow_graph_1.CfgVertexType.EndMarker : vertex.end !== undefined;
-    }
-    /** Get all AST nodes for the predecessor vertices that are leaf nodes and exit vertices */
-    getPredecessorNodes(vertexId) {
-        return this.config.controlFlow.graph.outgoingEdges(vertexId)?.keys() // outgoing dependency edges are incoming CFG edges
-            .map(id => this.getCfgVertex(id))
-            .flatMap(vertex => {
-            if (vertex === undefined) {
-                return [];
-            }
-            else if (this.shouldSkipVertex(vertex)) {
-                return this.getPredecessorNodes(vertex.id);
-            }
-            else {
-                return [this.getNormalizedAst((0, control_flow_graph_1.getVertexRootId)(vertex))];
-            }
-        })
-            .filter(assert_1.isNotUndefined)
-            .toArray() ?? [];
-    }
-    shouldWiden(vertex) {
-        return (this.visited.get(vertex.id) ?? 0) >= this.config.ctx.config.abstractInterpretation.dataFrame.wideningThreshold;
-    }
-    clearUnassignedInfo(node) {
-        if ((0, absint_info_1.hasDataFrameInfoMarker)(node, absint_info_1.DataFrameInfoMarker.Unassigned)) {
-            if (node.info.dataFrame?.domain !== undefined) {
-                node.info.dataFrame = { domain: node.info.dataFrame.domain };
-            }
-            else {
-                delete node.info.dataFrame;
-            }
-        }
-    }
-}
-exports.DataFrameShapeInferenceVisitor = DataFrameShapeInferenceVisitor;
-//# sourceMappingURL=absint-visitor.js.map

package/abstract-interpretation/data-frame/mappers/assignment-mapper.d.ts

@@ -1,21 +0,0 @@
-import type { DataflowGraph } from '../../../dataflow/graph/graph';
-import type { RNode } from '../../../r-bridge/lang-4.x/ast/model/model';
-import type { RString } from '../../../r-bridge/lang-4.x/ast/model/nodes/r-string';
-import type { RSymbol } from '../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
-import type { ParentInformation } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { DataFrameAssignmentInfo } from '../absint-info';
-import type { ReadOnlyFlowrAnalyzerContext } from '../../../project/context/flowr-analyzer-context';
-/**
- * Maps a concrete data frame assignment to data frame assignment info containing the ids of the identifier and assigned expression.
- * We currently do not support function assignments dealing with data frames.
- * @param identifier - The R node of the variable identifier
- * @param expression - The R node of the assigned expression
- * @param dfg  - The data flow graph for resolving the arguments
- * @param ctx - The analysis context
- * @returns Data frame assignment info containing the IDs of the identifier and expression, or `undefined` if the node does not represent a data frame assignment
- */
-export declare function mapDataFrameVariableAssignment(identifier: RSymbol<ParentInformation> | RString<ParentInformation>, expression: RNode<ParentInformation>, dfg: DataflowGraph, ctx: ReadOnlyFlowrAnalyzerContext): DataFrameAssignmentInfo | undefined;
-/**
- * Checks whether a R node represents an assignment target, i.e. is a `RSymbol` or `RString`.
- */
-export declare function isAssignmentTarget(node: RNode<ParentInformation> | undefined): node is RSymbol<ParentInformation> | RString<ParentInformation>;

package/abstract-interpretation/data-frame/mappers/assignment-mapper.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapDataFrameVariableAssignment = mapDataFrameVariableAssignment;
-exports.isAssignmentTarget = isAssignmentTarget;
-const config_1 = require("../../../config");
-const type_1 = require("../../../r-bridge/lang-4.x/ast/model/type");
-const arguments_1 = require("./arguments");
-/**
- * Maps a concrete data frame assignment to data frame assignment info containing the ids of the identifier and assigned expression.
- * We currently do not support function assignments dealing with data frames.
- * @param identifier - The R node of the variable identifier
- * @param expression - The R node of the assigned expression
- * @param dfg  - The data flow graph for resolving the arguments
- * @param ctx - The analysis context
- * @returns Data frame assignment info containing the IDs of the identifier and expression, or `undefined` if the node does not represent a data frame assignment
- */
-function mapDataFrameVariableAssignment(identifier, expression, dfg, ctx) {
-    const resolveInfo = { graph: dfg, idMap: dfg.idMap, full: true, resolve: config_1.VariableResolve.Alias, ctx };
-    if (!(0, arguments_1.isDataFrameArgument)(expression, resolveInfo)) {
-        return;
-    }
-    return {
-        type: 'assignment',
-        identifier: identifier.info.id,
-        expression: expression.info.id
-    };
-}
-/**
- * Checks whether a R node represents an assignment target, i.e. is a `RSymbol` or `RString`.
- */
-function isAssignmentTarget(node) {
-    return node?.type === type_1.RType.Symbol || node?.type === type_1.RType.String;
-}
-//# sourceMappingURL=assignment-mapper.js.map

package/documentation/doc-util/doc-print.d.ts

@@ -1,5 +0,0 @@
-/**
- * Writes the wiki documentation to the specified output path.
- * Returns true if the file was updated, false if it was unchanged.
- */
-export declare function writeWikiTo(text: string, output_path: string, check_change?: boolean): boolean;

package/documentation/doc-util/doc-print.js

@@ -1,36 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeWikiTo = writeWikiTo;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-/* eslint-disable */
-const IgnoreRegex = /[0-9]+(\.[0-9]+)? ?ms|"timing":\s*[0-9]+(\.0-9)?,?|tmp-[A-Za-z0-9-]+/g;
-/* eslint-enable */
-/**
- * Checks whether the file contains a different content, but ignores timing and some other non-semantic changes.
- */
-function didFileChange(filePath, content) {
-    if (!fs_1.default.existsSync(filePath)) {
-        return true; // If the file does not exist, it is considered changed.
-    }
-    const currentContent = fs_1.default.readFileSync(filePath, 'utf-8');
-    const cleanedCurrentContent = currentContent.replace(IgnoreRegex, '');
-    const cleanedNewContent = content.replace(IgnoreRegex, '');
-    return cleanedCurrentContent !== cleanedNewContent;
-}
-/**
- * Writes the wiki documentation to the specified output path.
- * Returns true if the file was updated, false if it was unchanged.
- */
-function writeWikiTo(text, output_path, check_change = true) {
-    if (!check_change || didFileChange(output_path, text)) {
-        fs_1.default.mkdirSync(path_1.default.dirname(output_path), { recursive: true });
-        fs_1.default.writeFileSync(output_path, text, 'utf-8');
-        return true;
-    }
-    return false;
-}
-//# sourceMappingURL=doc-print.js.map