@eagleoutice/flowr 2.6.1 → 2.6.3

package/abstract-interpretation/data-frame/semantics.js

@@ -4,7 +4,9 @@ exports.DataFrameOperationNames = exports.ConstraintType = void 0;
 exports.applyDataFrameSemantics = applyDataFrameSemantics;
 exports.getConstraintType = getConstraintType;
 const assert_1 = require("../../util/assert");
-const domain_1 = require("./domain");
+const lattice_1 = require("../domains/lattice");
+const positive_interval_domain_1 = require("../domains/positive-interval-domain");
+const dataframe_domain_1 = require("./dataframe-domain");
 /**
  * Represents the different types of resulting constraints that are inferred by abstract data frame operations.
  */
@@ -50,7 +52,6 @@ exports.DataFrameOperationNames = Object.keys(DataFrameSemanticsMapper);
 /**
  * Applies the abstract semantics of an abstract data frame operation with respect to the data frame shape domain.
  * This expects that all arguments have already been sanitized according to the original concrete data frame function (e.g. by replacing duplicate/invalid column names).
- *
  * @param operation - The name of the abstract operation to apply the semantics of
  * @param value     - The abstract data frame shape of the operand of the abstract operation
  * @param args      - The arguments for applying the abstract semantics of the abstract operation
@@ -69,255 +70,272 @@ function getConstraintType(operation) {
     return DataFrameSemanticsMapper[operation].type;
 }
 function applyCreateSemantics(value, { colnames, rows }) {
-    const cols = colnames?.length;
-    return {
-        colnames: colnames?.every(assert_1.isNotUndefined) ? colnames : domain_1.ColNamesTop,
-        cols: cols !== undefined ? [cols, cols] : domain_1.IntervalTop,
-        rows: Array.isArray(rows) ? rows : typeof rows === 'number' ? [rows, rows] : domain_1.IntervalTop
-    };
+    const colnamesValue = colnames?.every(assert_1.isNotUndefined) ? colnames : lattice_1.Top;
+    const colsValue = colnames !== undefined ? [colnames.length, colnames.length] : positive_interval_domain_1.PosIntervalTop;
+    const rowsValue = Array.isArray(rows) ? rows : typeof rows === 'number' ? [rows, rows] : positive_interval_domain_1.PosIntervalTop;
+    return new dataframe_domain_1.DataFrameDomain({
+        colnames: value.colnames.create(colnamesValue),
+        cols: value.cols.create(colsValue),
+        rows: value.rows.create(rowsValue)
+    });
 }
 function applyReadSemantics(value, { colnames, rows }) {
     return applyCreateSemantics(value, { colnames, rows });
 }
 function applyAccessColsSemantics(value, { columns }) {
     if (columns?.every(col => typeof col === 'string')) {
-        return {
-            ...value,
-            colnames: (0, domain_1.joinColNames)(value.colnames, columns)
-        };
+        return new dataframe_domain_1.DataFrameDomain({
+            colnames: value.colnames.join(columns),
+            cols: value.cols,
+            rows: value.rows
+        });
     }
     else if (columns?.every(col => typeof col === 'number')) {
-        return {
-            ...value,
-            cols: columns.reduce((a, b) => (0, domain_1.maxInterval)(a, [b, b]), value.cols)
-        };
+        return new dataframe_domain_1.DataFrameDomain({
+            colnames: value.colnames,
+            cols: columns?.reduce((current, col) => current.max([col, col]), value.cols),
+            rows: value.rows
+        });
     }
     return value;
 }
 function applyAccessRowsSemantics(value, { rows }) {
     if (rows !== undefined) {
-        return {
-            ...value,
-            rows: rows.reduce((a, b) => (0, domain_1.maxInterval)(a, [b, b]), value.rows)
-        };
+        return new dataframe_domain_1.DataFrameDomain({
+            colnames: value.colnames,
+            cols: value.cols,
+            rows: rows.reduce((current, row) => current.max([row, row]), value.rows)
+        });
     }
     return value;
 }
 function applyAssignColsSemantics(value, { columns }) {
     if (columns?.every(col => typeof col === 'string')) {
         const cols = columns.length;
-        return {
-            ...value,
-            colnames: (0, domain_1.joinColNames)(value.colnames, columns),
-            cols: (0, domain_1.maxInterval)((0, domain_1.addInterval)(value.cols, [0, cols]), [cols, cols])
-        };
+        return new dataframe_domain_1.DataFrameDomain({
+            colnames: value.colnames.join(columns),
+            cols: value.cols.add([0, cols]).max([cols, cols]),
+            rows: value.rows
+        });
     }
     else if (columns?.every(col => typeof col === 'number')) {
-        return {
-            ...value,
-            colnames: domain_1.ColNamesTop,
-            cols: columns.reduce((a, b) => (0, domain_1.maxInterval)(a, [b, b]), value.cols)
-        };
+        return new dataframe_domain_1.DataFrameDomain({
+            colnames: value.colnames.top(),
+            cols: columns.reduce((current, col) => current.max([col, col]), value.cols),
+            rows: value.rows
+        });
     }
-    return {
-        ...value,
-        colnames: domain_1.ColNamesTop,
-        cols: (0, domain_1.extendIntervalToInfinity)(value.cols)
-    };
+    return new dataframe_domain_1.DataFrameDomain({
+        colnames: value.colnames.top(),
+        cols: value.cols.extendUp(),
+        rows: value.rows
+    });
 }
 function applyAssignRowsSemantics(value, { rows }) {
     if (rows !== undefined) {
-        return {
-            ...value,
-            rows: rows.reduce((a, b) => (0, domain_1.maxInterval)(a, [b, b]), value.rows)
-        };
+        return new dataframe_domain_1.DataFrameDomain({
+            colnames: value.colnames,
+            cols: value.cols,
+            rows: rows.reduce((current, row) => current.max([row, row]), value.rows)
+        });
     }
-    return {
-        ...value,
-        rows: (0, domain_1.extendIntervalToInfinity)(value.rows)
-    };
+    return new dataframe_domain_1.DataFrameDomain({
+        colnames: value.colnames,
+        cols: value.cols,
+        rows: value.rows.extendUp()
+    });
 }
 function applySetColNamesSemantics(value, { colnames }, options) {
     if (options?.partial) {
-        return {
-            ...value,
-            colnames: colnames?.every(assert_1.isNotUndefined) ? (0, domain_1.joinColNames)(value.colnames, colnames) : domain_1.ColNamesTop,
-        };
+        return new dataframe_domain_1.DataFrameDomain({
+            colnames: colnames?.every(assert_1.isNotUndefined) ? value.colnames.join(colnames) : value.colnames.top(),
+            cols: value.cols,
+            rows: value.rows
+        });
     }
-    const cols = colnames?.length;
-    const allColNames = value.cols !== domain_1.IntervalBottom && cols !== undefined && cols >= value.cols[1];
-    return {
-        ...value,
-        colnames: allColNames && colnames?.every(assert_1.isNotUndefined) ? colnames : domain_1.ColNamesTop,
-    };
+    const allColNames = colnames?.every(assert_1.isNotUndefined) && value.cols.value !== lattice_1.Bottom && colnames.length >= value.cols.value[1];
+    return new dataframe_domain_1.DataFrameDomain({
+        colnames: allColNames ? value.colnames.create(colnames) : value.colnames.top(),
+        cols: value.cols,
+        rows: value.rows
+    });
 }
 function applyAddColsSemantics(value, { colnames }) {
-    const cols = colnames?.length;
-    return {
-        ...value,
-        colnames: colnames?.every(assert_1.isNotUndefined) ? (0, domain_1.joinColNames)(value.colnames, colnames) : domain_1.ColNamesTop,
-        cols: cols !== undefined ? (0, domain_1.addInterval)(value.cols, [cols, cols]) : (0, domain_1.extendIntervalToInfinity)(value.cols)
-    };
+    return new dataframe_domain_1.DataFrameDomain({
+        colnames: colnames?.every(assert_1.isNotUndefined) ? value.colnames.join(colnames) : value.colnames.top(),
+        cols: colnames !== undefined ? value.cols.add([colnames.length, colnames.length]) : value.cols.extendUp(),
+        rows: value.rows
+    });
 }
 function applyAddRowsSemantics(value, { rows }) {
-    return {
-        ...value,
-        rows: rows !== undefined ? (0, domain_1.addInterval)(value.rows, [rows, rows]) : (0, domain_1.extendIntervalToInfinity)(value.rows)
-    };
+    if (value.cols.value !== lattice_1.Bottom && value.cols.value[0] === 0) {
+        return new dataframe_domain_1.DataFrameDomain({
+            ...value,
+            colnames: value.colnames.top(),
+            cols: rows !== undefined ? value.cols.add([1, 1]) : value.cols.top(),
+            rows: rows !== undefined ? value.rows.add([rows, rows]) : value.rows.extendUp()
+        });
+    }
+    return new dataframe_domain_1.DataFrameDomain({
+        colnames: value.colnames,
+        cols: value.cols,
+        rows: rows !== undefined ? value.rows.add([rows, rows]) : value.rows.extendUp()
+    });
 }
 function applyRemoveColsSemantics(value, { colnames }, options) {
-    const cols = colnames?.length;
     if (options?.maybe) {
-        return {
-            ...value,
-            colnames: colnames !== undefined ? (0, domain_1.subtractColNames)(value.colnames, colnames.filter(assert_1.isNotUndefined)) : value.colnames,
-            cols: cols !== undefined ? (0, domain_1.subtractInterval)(value.cols, [cols, 0]) : (0, domain_1.extendIntervalToZero)(value.cols)
-        };
+        return new dataframe_domain_1.DataFrameDomain({
+            colnames: colnames !== undefined ? value.colnames.subtract(colnames.filter(assert_1.isNotUndefined)) : value.colnames,
+            cols: colnames !== undefined ? value.cols.subtract([colnames.length, 0]) : value.cols.extendDown(),
+            rows: value.rows
+        });
     }
-    return {
-        ...value,
-        colnames: colnames !== undefined ? (0, domain_1.subtractColNames)(value.colnames, colnames.filter(assert_1.isNotUndefined)) : value.colnames,
-        cols: cols !== undefined ? (0, domain_1.subtractInterval)(value.cols, [cols, cols]) : (0, domain_1.extendIntervalToZero)(value.cols)
-    };
+    return new dataframe_domain_1.DataFrameDomain({
+        colnames: colnames !== undefined ? value.colnames.subtract(colnames.filter(assert_1.isNotUndefined)) : value.colnames,
+        cols: colnames !== undefined ? value.cols.subtract([colnames.length, colnames.length]) : value.cols.extendDown(),
+        rows: value.rows
+    });
 }
 function applyRemoveRowsSemantics(value, { rows }, options) {
     if (options?.maybe) {
-        return {
-            ...value,
-            cols: rows !== undefined ? (0, domain_1.subtractInterval)(value.cols, [rows, 0]) : (0, domain_1.extendIntervalToZero)(value.cols)
-        };
+        return new dataframe_domain_1.DataFrameDomain({
+            colnames: value.colnames,
+            cols: value.cols,
+            rows: rows !== undefined ? value.rows.subtract([rows, 0]) : value.rows.extendDown()
+        });
     }
-    return {
-        ...value,
-        rows: rows !== undefined ? (0, domain_1.subtractInterval)(value.rows, [rows, rows]) : (0, domain_1.extendIntervalToZero)(value.rows)
-    };
+    return new dataframe_domain_1.DataFrameDomain({
+        colnames: value.colnames,
+        cols: value.cols,
+        rows: rows !== undefined ? value.rows.subtract([rows, rows]) : value.rows.extendDown()
+    });
 }
 function applyConcatColsSemantics(value, { other }) {
-    return {
-        ...value,
-        colnames: (0, domain_1.joinColNames)(value.colnames, other.colnames),
-        cols: (0, domain_1.addInterval)(value.cols, other.cols)
-    };
+    return new dataframe_domain_1.DataFrameDomain({
+        colnames: value.colnames.join(other.colnames),
+        cols: value.cols.add(other.cols),
+        rows: value.rows
+    });
 }
 function applyConcatRowsSemantics(value, { other }) {
-    if (value.cols !== domain_1.IntervalBottom && value.cols[0] === 0) {
-        return {
+    if (value.cols.value !== lattice_1.Bottom && value.cols.value[0] === 0) {
+        return new dataframe_domain_1.DataFrameDomain({
             ...value,
-            colnames: (0, domain_1.joinColNames)(value.colnames, other.colnames),
-            cols: (0, domain_1.joinInterval)(value.cols, other.cols),
-            rows: (0, domain_1.addInterval)(value.rows, other.rows)
-        };
+            colnames: value.colnames.join(other.colnames),
+            cols: value.cols.join(other.cols),
+            rows: value.rows.add(other.rows)
+        });
     }
-    return {
-        ...value,
-        rows: (0, domain_1.addInterval)(value.rows, other.rows)
-    };
+    return new dataframe_domain_1.DataFrameDomain({
+        colnames: value.colnames,
+        cols: value.cols,
+        rows: value.rows.add(other.rows)
+    });
 }
 function applySubsetColsSemantics(value, { colnames }, options) {
-    const cols = colnames?.length;
     if (options?.duplicateCols) {
-        return {
-            ...value,
-            colnames: domain_1.ColNamesTop,
-            cols: cols !== undefined ? [cols, cols] : domain_1.IntervalTop
-        };
+        return new dataframe_domain_1.DataFrameDomain({
+            colnames: value.colnames.top(),
+            cols: colnames !== undefined ? value.cols.create([colnames.length, colnames.length]) : value.cols.top(),
+            rows: value.rows
+        });
     }
     else if (options?.renamedCols) {
-        return {
-            ...value,
-            colnames: domain_1.ColNamesTop,
-            cols: cols !== undefined ? (0, domain_1.minInterval)(value.cols, [cols, cols]) : (0, domain_1.extendIntervalToZero)(value.cols)
-        };
+        return new dataframe_domain_1.DataFrameDomain({
+            colnames: value.colnames.top(),
+            cols: colnames !== undefined ? value.cols.min([colnames.length, colnames.length]) : value.cols.extendDown(),
+            rows: value.rows
+        });
     }
-    return {
-        ...value,
-        colnames: colnames?.every(assert_1.isNotUndefined) ? (0, domain_1.meetColNames)(value.colnames, colnames) : value.colnames,
-        cols: cols !== undefined ? (0, domain_1.minInterval)(value.cols, [cols, cols]) : (0, domain_1.extendIntervalToZero)(value.cols)
-    };
+    return new dataframe_domain_1.DataFrameDomain({
+        colnames: colnames?.every(assert_1.isNotUndefined) ? value.colnames.meet(colnames) : value.colnames,
+        cols: colnames !== undefined ? value.cols.min([colnames.length, colnames.length]) : value.cols.extendDown(),
+        rows: value.rows
+    });
 }
 function applySubsetRowsSemantics(value, { rows }, options) {
     if (options?.duplicateRows) {
-        return {
-            ...value,
-            rows: rows !== undefined ? [rows, rows] : domain_1.IntervalTop
-        };
+        return new dataframe_domain_1.DataFrameDomain({
+            colnames: value.colnames,
+            cols: value.cols,
+            rows: rows !== undefined ? value.rows.create([rows, rows]) : value.rows.top()
+        });
     }
-    return {
-        ...value,
-        rows: rows !== undefined ? (0, domain_1.minInterval)(value.rows, [rows, rows]) : (0, domain_1.extendIntervalToZero)(value.rows)
-    };
+    return new dataframe_domain_1.DataFrameDomain({
+        colnames: value.colnames,
+        cols: value.cols,
+        rows: rows !== undefined ? value.rows.min([rows, rows]) : value.rows.extendDown()
+    });
 }
 function applyFilterRowsSemantics(value, { condition }) {
-    return {
-        ...value,
-        rows: condition ? value.rows : condition === false ? [0, 0] : (0, domain_1.extendIntervalToZero)(value.rows)
-    };
+    return new dataframe_domain_1.DataFrameDomain({
+        colnames: value.colnames,
+        cols: value.cols,
+        rows: condition ? value.rows : condition === false ? value.rows.create([0, 0]) : value.rows.extendDown()
+    });
 }
 function applyMutateColsSemantics(value, { colnames }) {
-    const cols = colnames?.length;
-    return {
-        ...value,
-        colnames: colnames?.every(assert_1.isNotUndefined) ? (0, domain_1.joinColNames)(value.colnames, colnames) : domain_1.ColNamesTop,
-        cols: cols !== undefined ? (0, domain_1.maxInterval)((0, domain_1.addInterval)(value.cols, [0, cols]), [cols, cols]) : (0, domain_1.extendIntervalToInfinity)(value.cols)
-    };
+    return new dataframe_domain_1.DataFrameDomain({
+        colnames: colnames?.every(assert_1.isNotUndefined) ? value.colnames.join(colnames) : value.colnames.top(),
+        cols: colnames !== undefined ? value.cols.add([0, colnames.length]).max([colnames.length, colnames.length]) : value.cols.extendUp(),
+        rows: value.rows
+    });
 }
 function applyGroupBySemantics(value, { by }, options) {
     if (options?.mutatedCols) {
-        return {
-            ...value,
-            colnames: by.every(assert_1.isNotUndefined) ? (0, domain_1.joinColNames)(value.colnames, by) : domain_1.ColNamesTop,
-            cols: (0, domain_1.addInterval)(value.cols, [0, by.length])
-        };
+        return new dataframe_domain_1.DataFrameDomain({
+            colnames: by.every(assert_1.isNotUndefined) ? value.colnames.join(by) : value.colnames.top(),
+            cols: value.cols.add([0, by.length]),
+            rows: value.rows
+        });
     }
     // Group by only marks columns as groups but does not change the shape itself
     return value;
 }
 function applySummarizeSemantics(value, { colnames }) {
-    const cols = colnames?.length;
-    return {
-        ...value,
-        colnames: colnames?.every(assert_1.isNotUndefined) ? (0, domain_1.joinColNames)(value.colnames, colnames) : domain_1.ColNamesTop,
-        cols: cols !== undefined ? (0, domain_1.minInterval)((0, domain_1.addInterval)(value.cols, [0, cols]), [cols, Infinity]) : (0, domain_1.extendIntervalToInfinity)(value.rows),
-        rows: (0, domain_1.maxInterval)((0, domain_1.minInterval)(value.rows, [1, Infinity]), [0, 1])
-    };
+    return new dataframe_domain_1.DataFrameDomain({
+        colnames: colnames?.every(assert_1.isNotUndefined) ? value.colnames.join(colnames) : value.colnames.top(),
+        cols: colnames !== undefined ? value.cols.add([0, colnames.length]).min([colnames.length, +Infinity]) : value.cols.extendUp(),
+        rows: value.rows.min([1, +Infinity]).max([0, 1])
+    });
 }
 function applyJoinSemantics(value, { other, by }, options) {
     // Merge two intervals by creating the maximum of the lower bounds and adding the upper bounds
     const mergeInterval = (interval1, interval2) => {
-        if (interval1 === domain_1.IntervalBottom || interval2 === domain_1.IntervalBottom) {
-            return domain_1.IntervalBottom;
+        if (interval1.value === lattice_1.Bottom || interval2.value === lattice_1.Bottom) {
+            return interval1.bottom();
         }
         else {
-            return [Math.max(interval1[0], interval2[0]), interval1[1] + interval2[1]];
+            return new positive_interval_domain_1.PosIntervalDomain([Math.max(interval1.value[0], interval2.value[0]), interval1.value[1] + interval2.value[1]]);
         }
     };
     // Creating the Cartesian product of two intervals by keeping the lower bound and multiplying the upper bounds
     const productInterval = (lower, interval1, interval2) => {
-        if (lower === domain_1.IntervalBottom || interval1 === domain_1.IntervalBottom || interval2 === domain_1.IntervalBottom) {
-            return domain_1.IntervalBottom;
+        if (lower.value === lattice_1.Bottom || interval1.value === lattice_1.Bottom || interval2.value === lattice_1.Bottom) {
+            return lower.bottom();
         }
         else {
-            return [lower[0], interval1[1] * interval2[1]];
+            return new positive_interval_domain_1.PosIntervalDomain([lower.value[0], interval1.value[1] * interval2.value[1]]);
         }
     };
-    const commonCols = (0, domain_1.meetColNames)(value.colnames, other.colnames);
+    const commonCols = value.colnames.meet(other.colnames);
     let duplicateCols; // whether columns may be renamed due to occurrence in both data frames
     let productRows; // whether the resulting rows may be a Cartesian product of the rows of the data frames
     if (options?.natural) {
         duplicateCols = false;
-        productRows = commonCols !== domain_1.ColNamesTop && commonCols.length === 0;
+        productRows = commonCols.isValue() && commonCols.value.size === 0;
     }
     else if (by === undefined) {
         duplicateCols = true;
         productRows = true;
     }
     else if (by.length === 0) {
-        duplicateCols = commonCols === domain_1.ColNamesTop || commonCols.length > 0;
+        duplicateCols = commonCols.isTop() || (commonCols.isValue() && commonCols.value.size > 0);
         productRows = true;
     }
     else if (by.every(assert_1.isNotUndefined)) {
-        const remainingCols = (0, domain_1.subtractColNames)(commonCols, by);
-        duplicateCols = remainingCols === domain_1.ColNamesTop || remainingCols.length > 0;
+        const remainingCols = commonCols.subtract(by);
+        duplicateCols = remainingCols.isTop() || (remainingCols.isValue() && remainingCols.value.size > 0);
         productRows = false;
     }
     else {
@@ -328,7 +346,7 @@ function applyJoinSemantics(value, { other, by }, options) {
     let rows;
     switch (joinType) {
         case 'inner':
-            rows = (0, domain_1.extendIntervalToZero)((0, domain_1.minInterval)(value.rows, other.rows));
+            rows = value.rows.min(other.rows).extendDown();
             break;
         case 'left':
             rows = value.rows;
@@ -342,22 +360,21 @@ function applyJoinSemantics(value, { other, by }, options) {
         default:
             (0, assert_1.assertUnreachable)(joinType);
     }
-    const byCols = by?.length;
-    return {
+    return new dataframe_domain_1.DataFrameDomain({
         ...value,
-        colnames: duplicateCols ? domain_1.ColNamesTop : (0, domain_1.joinColNames)(value.colnames, other.colnames),
-        cols: byCols !== undefined ? (0, domain_1.subtractInterval)((0, domain_1.addInterval)(value.cols, other.cols), [byCols, byCols]) : mergeInterval(value.cols, other.cols),
+        colnames: duplicateCols ? value.colnames.top() : value.colnames.join(other.colnames),
+        cols: by !== undefined ? value.cols.add(other.cols).subtract([by.length, by.length]) : mergeInterval(value.cols, other.cols),
         rows: productRows ? productInterval(rows, value.rows, other.rows) : rows
-    };
+    });
 }
 function applyIdentitySemantics(value, 
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
 _args) {
     return value;
 }
-function applyUnknownSemantics(_value, 
+function applyUnknownSemantics(value, 
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
 _args) {
-    return domain_1.DataFrameTop;
+    return value.top();
 }
 //# sourceMappingURL=semantics.js.map

package/abstract-interpretation/data-frame/shape-inference.d.ts

@@ -1,27 +1,25 @@
-import type { FlowrConfigOptions } from '../../config';
 import { type ControlFlowInformation } from '../../control-flow/control-flow-graph';
 import type { DataflowGraph } from '../../dataflow/graph/graph';
 import type { RNode } from '../../r-bridge/lang-4.x/ast/model/model';
 import type { NormalizedAst, 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 AbstractInterpretationInfo } from './absint-info';
-import { type DataFrameDomain, type DataFrameStateDomain } from './domain';
+import { type DataFrameDomain, DataFrameStateDomain } from './dataframe-domain';
+import type { ReadOnlyFlowrAnalyzerContext } from '../../project/context/flowr-analyzer-context';
 /**
  * Infers the shape of data frames by performing abstract interpretation using the control flow graph of a program.
  * This directly attaches the inferred data frames shapes to the AST (see {@link AbstractInterpretationInfo}).
- *
  * @param cfinfo - The control flow information containing the control flow graph
  * @param dfg    - The data flow graph to resolve variable origins and function arguments
  * @param ast    - The abstract syntax tree to resolve node IDs to AST nodes
- * @param config - The flowR configuration to use for the shape inference
+ * @param ctx    - The current flowr analyzer context
  * @returns The abstract data frame state at the exit node of the control flow graph (see {@link DataFrameStateDomain}).
  * The abstract data frame states for all other nodes are attached to the AST.
  */
-export declare function inferDataFrameShapes(cfinfo: ControlFlowInformation, dfg: DataflowGraph, ast: NormalizedAst<ParentInformation & AbstractInterpretationInfo>, config: FlowrConfigOptions): DataFrameStateDomain;
+export declare function inferDataFrameShapes(cfinfo: ControlFlowInformation, dfg: DataflowGraph, ast: NormalizedAst<ParentInformation & AbstractInterpretationInfo>, ctx: ReadOnlyFlowrAnalyzerContext): DataFrameStateDomain;
 /**
  * Resolves the abstract data frame shape of a node in the AST.
  * This requires that the data frame shape inference has been executed before using {@link inferDataFrameShapes}.
- *
  * @param id     - The node or node ID to get the data frame shape for
  * @param dfg    - The data flow graph used to resolve the data frame shape
  * @param domain - An optional abstract data frame state domain used to resolve the data frame shape (defaults to the state at the requested node)
@@ -30,7 +28,6 @@ export declare function inferDataFrameShapes(cfinfo: ControlFlowInformation, dfg
 export declare function resolveIdToDataFrameShape(id: RNode<ParentInformation & AbstractInterpretationInfo> | NodeId | undefined, dfg: DataflowGraph | undefined, domain?: DataFrameStateDomain): DataFrameDomain | undefined;
 /**
  * Gets all origins of a variable in the data flow graph that have already been visited.
- *
  * @param node - The node to get the origins for
  * @param dfg  - The data flow graph for resolving the origins
  * @returns The origins nodes of the variable

package/abstract-interpretation/data-frame/shape-inference.js

@@ -9,32 +9,31 @@ const dfg_get_origin_1 = require("../../dataflow/origin/dfg-get-origin");
 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");
 const assert_1 = require("../../util/assert");
+const abstract_domain_1 = require("../domains/abstract-domain");
 const absint_info_1 = require("./absint-info");
 const absint_visitor_1 = require("./absint-visitor");
-const domain_1 = require("./domain");
+const dataframe_domain_1 = require("./dataframe-domain");
 /**
  * Infers the shape of data frames by performing abstract interpretation using the control flow graph of a program.
  * This directly attaches the inferred data frames shapes to the AST (see {@link AbstractInterpretationInfo}).
- *
  * @param cfinfo - The control flow information containing the control flow graph
  * @param dfg    - The data flow graph to resolve variable origins and function arguments
  * @param ast    - The abstract syntax tree to resolve node IDs to AST nodes
- * @param config - The flowR configuration to use for the shape inference
+ * @param ctx    - The current flowr analyzer context
  * @returns The abstract data frame state at the exit node of the control flow graph (see {@link DataFrameStateDomain}).
  * The abstract data frame states for all other nodes are attached to the AST.
  */
-function inferDataFrameShapes(cfinfo, dfg, ast, config) {
-    const visitor = new absint_visitor_1.DataFrameShapeInferenceVisitor({ controlFlow: cfinfo, dfg: dfg, normalizedAst: ast, flowrConfig: config });
+function inferDataFrameShapes(cfinfo, dfg, ast, ctx) {
+    const visitor = new absint_visitor_1.DataFrameShapeInferenceVisitor({ controlFlow: cfinfo, dfg: dfg, normalizedAst: ast, ctx });
     visitor.start();
     const exitPoints = cfinfo.exitPoints.map(id => cfinfo.graph.getVertex(id)).filter(assert_1.isNotUndefined);
     const exitNodes = exitPoints.map(vertex => ast.idMap.get((0, control_flow_graph_1.getVertexRootId)(vertex))).filter(assert_1.isNotUndefined);
-    const result = exitNodes.map(node => node.info.dataFrame?.domain ?? new Map());
-    return (0, domain_1.joinDataFrameStates)(...result);
+    const domains = exitNodes.map(node => node.info.dataFrame?.domain).filter(assert_1.isNotUndefined);
+    return dataframe_domain_1.DataFrameStateDomain.bottom().joinAll(domains);
 }
 /**
  * Resolves the abstract data frame shape of a node in the AST.
  * This requires that the data frame shape inference has been executed before using {@link inferDataFrameShapes}.
- *
  * @param id     - The node or node ID to get the data frame shape for
  * @param dfg    - The data flow graph used to resolve the data frame shape
  * @param domain - An optional abstract data frame state domain used to resolve the data frame shape (defaults to the state at the requested node)
@@ -55,7 +54,7 @@ function resolveIdToDataFrameShape(id, dfg, domain) {
     if (node.type === type_1.RType.Symbol) {
         const values = getVariableOrigins(node.info.id, dfg).map(origin => domain.get(origin.info.id));
         if (values.length > 0 && values.every(assert_1.isNotUndefined)) {
-            return (0, domain_1.joinDataFrames)(...values);
+            return abstract_domain_1.AbstractDomain.joinAll(values);
         }
     }
     else if (node.type === type_1.RType.Argument && node.value !== undefined) {
@@ -79,7 +78,7 @@ function resolveIdToDataFrameShape(id, dfg, domain) {
         if (node.otherwise !== undefined) {
             const values = [node.then, node.otherwise].map(entry => resolveIdToDataFrameShape(entry, dfg, domain));
             if (values.length > 0 && values.every(assert_1.isNotUndefined)) {
-                return (0, domain_1.joinDataFrames)(...values);
+                return abstract_domain_1.AbstractDomain.joinAll(values);
             }
         }
     }
@@ -87,14 +86,13 @@ function resolveIdToDataFrameShape(id, dfg, domain) {
         if (call.args.length === 3) {
             const values = call.args.slice(1, 3).map(entry => resolveIdToDataFrameShape(entry.nodeId, dfg, domain));
             if (values.length > 0 && values.every(assert_1.isNotUndefined)) {
-                return (0, domain_1.joinDataFrames)(...values);
+                return abstract_domain_1.AbstractDomain.joinAll(values);
             }
         }
     }
 }
 /**
  * Gets all origins of a variable in the data flow graph that have already been visited.
- *
  * @param node - The node to get the origins for
  * @param dfg  - The data flow graph for resolving the origins
  * @returns The origins nodes of the variable