@eagleoutice/flowr 2.9.14 → 2.10.2

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

@@ -10,8 +10,10 @@ const retriever_1 = require("../../../r-bridge/retriever");
 const assert_1 = require("../../../util/assert");
 const dataframe_domain_1 = require("../dataframe-domain");
 const resolve_args_1 = require("../resolve-args");
+const semantics_1 = require("../semantics");
 const arguments_1 = require("./arguments");
 const identifier_1 = require("../../../dataflow/environments/identifier");
+const r_argument_1 = require("../../../r-bridge/lang-4.x/ast/model/nodes/r-argument");
 /**
  * Represents the different types of data frames in R
  */
@@ -26,43 +28,48 @@ var DataFrameType;
  * including information about the origin library of the functions and the type of the returned data frame.
  */
 const DataFrameFunctionMapper = {
-    'data.frame': { mapper: mapDataFrameCreate, library: 'base', returnType: DataFrameType.DataFrame },
-    'as.data.frame': { mapper: mapDataFrameConvert, library: 'base', returnType: DataFrameType.DataFrame },
-    'read.table': { mapper: mapDataFrameRead, library: 'utils', returnType: DataFrameType.DataFrame },
-    'read.csv': { mapper: mapDataFrameRead, library: 'utils', returnType: DataFrameType.DataFrame },
-    'read.csv2': { mapper: mapDataFrameRead, library: 'utils', returnType: DataFrameType.DataFrame },
-    'read.delim': { mapper: mapDataFrameRead, library: 'utils', returnType: DataFrameType.DataFrame },
-    'read.delim2': { mapper: mapDataFrameRead, library: 'utils', returnType: DataFrameType.DataFrame },
-    'read_table': { mapper: mapDataFrameRead, library: 'readr', returnType: DataFrameType.Tibble },
-    'read_csv': { mapper: mapDataFrameRead, library: 'readr', returnType: DataFrameType.Tibble },
-    'read_csv2': { mapper: mapDataFrameRead, library: 'readr', returnType: DataFrameType.Tibble },
-    'read_tsv': { mapper: mapDataFrameRead, library: 'readr', returnType: DataFrameType.Tibble },
-    'read_delim': { mapper: mapDataFrameRead, library: 'readr', returnType: DataFrameType.Tibble },
+    'data.frame': { mapper: mapDataFrameCreate, library: 'base', returnType: DataFrameType.DataFrame, alwaysDataFrame: true },
+    'as.data.frame': { mapper: mapDataFrameConvert, library: 'base', returnType: DataFrameType.DataFrame, alwaysDataFrame: true },
+    'read.table': { mapper: mapDataFrameRead, library: 'utils', returnType: DataFrameType.DataFrame, alwaysDataFrame: true },
+    'read.csv': { mapper: mapDataFrameRead, library: 'utils', returnType: DataFrameType.DataFrame, alwaysDataFrame: true },
+    'read.csv2': { mapper: mapDataFrameRead, library: 'utils', returnType: DataFrameType.DataFrame, alwaysDataFrame: true },
+    'read.delim': { mapper: mapDataFrameRead, library: 'utils', returnType: DataFrameType.DataFrame, alwaysDataFrame: true },
+    'read.delim2': { mapper: mapDataFrameRead, library: 'utils', returnType: DataFrameType.DataFrame, alwaysDataFrame: true },
+    'read_table': { mapper: mapDataFrameRead, library: 'readr', returnType: DataFrameType.Tibble, alwaysDataFrame: true },
+    'read_csv': { mapper: mapDataFrameRead, library: 'readr', returnType: DataFrameType.Tibble, alwaysDataFrame: true },
+    'read_csv2': { mapper: mapDataFrameRead, library: 'readr', returnType: DataFrameType.Tibble, alwaysDataFrame: true },
+    'read_tsv': { mapper: mapDataFrameRead, library: 'readr', returnType: DataFrameType.Tibble, alwaysDataFrame: true },
+    'read_delim': { mapper: mapDataFrameRead, library: 'readr', returnType: DataFrameType.Tibble, alwaysDataFrame: true },
     'cbind': { mapper: mapDataFrameColBind, library: 'base', returnType: DataFrameType.DataFrame },
     'rbind': { mapper: mapDataFrameRowBind, library: 'base', returnType: DataFrameType.DataFrame },
     'head': { mapper: mapDataFrameHeadTail, library: 'utils', returnType: DataFrameType.DataFrame },
     'tail': { mapper: mapDataFrameHeadTail, library: 'utils', returnType: DataFrameType.DataFrame },
     'subset': { mapper: mapDataFrameSubset, library: 'base', returnType: DataFrameType.DataFrame },
-    'filter': { mapper: mapDataFrameFilter, library: 'dplyr', returnType: DataFrameType.DataFrame },
-    'select': { mapper: mapDataFrameSelect, library: 'dplyr', returnType: DataFrameType.DataFrame },
-    'mutate': { mapper: mapDataFrameMutate, library: 'dplyr', returnType: DataFrameType.DataFrame },
-    'transform': { mapper: mapDataFrameMutate, library: 'base', returnType: DataFrameType.DataFrame },
-    'group_by': { mapper: mapDataFrameGroupBy, library: 'dplyr', returnType: DataFrameType.Tibble },
-    'summarise': { mapper: mapDataFrameSummarize, library: 'dplyr', returnType: DataFrameType.DataFrame },
-    'summarize': { mapper: mapDataFrameSummarize, library: 'dplyr', returnType: DataFrameType.DataFrame },
-    'inner_join': { mapper: mapDataFrameJoin, library: 'dplyr', returnType: DataFrameType.DataFrame },
-    'left_join': { mapper: mapDataFrameJoin, library: 'dplyr', returnType: DataFrameType.DataFrame },
-    'right_join': { mapper: mapDataFrameJoin, library: 'dplyr', returnType: DataFrameType.DataFrame },
-    'full_join': { mapper: mapDataFrameJoin, library: 'dplyr', returnType: DataFrameType.DataFrame },
-    'merge': { mapper: mapDataFrameJoin, library: 'base', returnType: DataFrameType.DataFrame },
-    'relocate': { mapper: mapDataFrameIdentity, library: 'dplyr', returnType: DataFrameType.DataFrame },
-    'arrange': { mapper: mapDataFrameIdentity, library: 'dplyr', returnType: DataFrameType.DataFrame }
+    'filter': { mapper: mapDataFrameFilter, library: 'dplyr', returnType: DataFrameType.DataFrame, alwaysDataFrame: true },
+    'select': { mapper: mapDataFrameSelect, library: 'dplyr', returnType: DataFrameType.DataFrame, alwaysDataFrame: true },
+    'mutate': { mapper: mapDataFrameMutate, library: 'dplyr', returnType: DataFrameType.DataFrame, alwaysDataFrame: true },
+    'transform': { mapper: mapDataFrameMutate, library: 'base', returnType: DataFrameType.DataFrame, alwaysDataFrame: true },
+    'group_by': { mapper: mapDataFrameGroupBy, library: 'dplyr', returnType: DataFrameType.Tibble, alwaysDataFrame: true },
+    'summarise': { mapper: mapDataFrameSummarize, library: 'dplyr', returnType: DataFrameType.DataFrame, alwaysDataFrame: true },
+    'summarize': { mapper: mapDataFrameSummarize, library: 'dplyr', returnType: DataFrameType.DataFrame, alwaysDataFrame: true },
+    'inner_join': { mapper: mapDataFrameJoin, library: 'dplyr', returnType: DataFrameType.DataFrame, alwaysDataFrame: true },
+    'left_join': { mapper: mapDataFrameJoin, library: 'dplyr', returnType: DataFrameType.DataFrame, alwaysDataFrame: true },
+    'right_join': { mapper: mapDataFrameJoin, library: 'dplyr', returnType: DataFrameType.DataFrame, alwaysDataFrame: true },
+    'full_join': { mapper: mapDataFrameJoin, library: 'dplyr', returnType: DataFrameType.DataFrame, alwaysDataFrame: true },
+    'merge': { mapper: mapDataFrameJoin, library: 'base', returnType: DataFrameType.DataFrame, alwaysDataFrame: true },
+    'relocate': { mapper: mapDataFrameIdentity, library: 'dplyr', returnType: DataFrameType.DataFrame, alwaysDataFrame: true },
+    'arrange': { mapper: mapDataFrameIdentity, library: 'dplyr', returnType: DataFrameType.DataFrame, alwaysDataFrame: true }
 };
 /**
  * List of other data frame functions that are not explicitly supported but may return data frames.
  */
 const OtherDataFrameFunctions = [
     {
+        type: 'entry_point',
+        names: ['as.data.frame.matrix'], // S3 dispatch of `as.data.frame`
+        library: 'base',
+        returnType: DataFrameType.DataFrame
+    }, {
         type: 'entry_point',
         names: ['anova', 'AIC', 'BIC'],
         library: 'anova',
@@ -72,11 +79,6 @@ const OtherDataFrameFunctions = [
         names: ['Anova', 'Manova'],
         library: 'car',
         returnType: DataFrameType.DataFrame
-    }, {
-        type: 'entry_point',
-        names: ['lmer'],
-        library: 'lme4',
-        returnType: DataFrameType.DataFrame
     }, {
         type: 'entry_point',
         names: ['data_frame', 'as_data_frame'],
@@ -115,7 +117,7 @@ const OtherDataFrameFunctions = [
         dataFrame: { pos: 0, name: 'object' }
     }, {
         type: 'transformation',
-        names: ['unique', 't'],
+        names: ['unique', 'droplevels'],
         library: 'base',
         returnType: DataFrameType.DataFrame,
         dataFrame: { pos: 0, name: 'x' }
@@ -151,6 +153,7 @@ const OtherDataFrameFunctions = [
         ],
         library: 'dplyr',
         returnType: DataFrameType.DataFrame,
+        alwaysDataFrame: true,
         dataFrame: { pos: 0, name: '.data' }
     }, {
         type: 'transformation',
@@ -163,6 +166,7 @@ const OtherDataFrameFunctions = [
         ],
         library: 'dplyr',
         returnType: DataFrameType.Tibble,
+        alwaysDataFrame: true,
         dataFrame: { pos: 0, name: '.tbl' }
     }, {
         type: 'transformation',
@@ -173,12 +177,14 @@ const OtherDataFrameFunctions = [
         ],
         library: 'dplyr',
         returnType: DataFrameType.DataFrame,
+        alwaysDataFrame: true,
         dataFrame: { pos: 0, name: 'x' }
     }, {
         type: 'transformation',
         names: ['bind_cols', 'bind_rows'],
         library: 'dplyr',
-        returnType: DataFrameType.DataFrame
+        returnType: DataFrameType.DataFrame,
+        alwaysDataFrame: true
     }, {
         type: 'transformation',
         names: [
@@ -193,6 +199,7 @@ const OtherDataFrameFunctions = [
         names: ['add_column', 'add_row', 'add_case'],
         library: 'tibble',
         returnType: DataFrameType.Tibble,
+        alwaysDataFrame: true,
         dataFrame: { pos: 0, name: '.data' }
     }, {
         type: 'transformation',
@@ -200,6 +207,20 @@ const OtherDataFrameFunctions = [
         library: 'data.table',
         returnType: DataFrameType.DataTable,
         dataFrame: { pos: 0, name: 'data' }
+    }, {
+        type: 'modification',
+        names: ['setNames'],
+        library: 'stats',
+        constraintType: semantics_1.ConstraintType.OperandModification,
+        returnType: DataFrameType.DataFrame,
+        dataFrame: { pos: 0, name: 'object' }
+    }, {
+        type: 'modification',
+        names: ['unname'],
+        library: 'base',
+        constraintType: semantics_1.ConstraintType.OperandModification,
+        returnType: DataFrameType.DataFrame,
+        dataFrame: { pos: 0, name: 'obj' }
     }
 ];
 /**
@@ -529,30 +550,33 @@ function mapDataFrameFunctionCall(node, inference, dfg, ctx) {
         return;
     }
     const resolveInfo = { graph: dfg, idMap: dfg.idMap, full: true, resolve: config_1.VariableResolve.Alias, ctx };
-    const n = identifier_1.Identifier.getName(node.functionName.content);
-    if (isDataFrameFunction(n)) {
-        const functionName = n;
-        const mapper = DataFrameFunctionMapper[functionName].mapper;
+    const functionName = identifier_1.Identifier.getName(node.functionName.content);
+    if (isDataFrameFunction(functionName)) {
+        const mapping = DataFrameFunctionMapper[functionName];
         const params = DataFrameFunctionParamsMapper[functionName];
         const args = (0, arguments_1.getFunctionArguments)(node, dfg);
         if ((0, arguments_1.hasCriticalArgument)(args, params.critical, resolveInfo)) {
             return [{ operation: 'unknown', operand: undefined }];
         }
         else {
-            return mapper(args, params, inference, resolveInfo);
+            return mapping.mapper(args, params, inference, resolveInfo) ?? (mapping.alwaysDataFrame ? [{ operation: 'unknown', operand: undefined }] : undefined);
         }
     }
     else {
-        const mapping = getOtherDataFrameFunction(identifier_1.Identifier.getName(node.functionName.content));
+        const mapping = getOtherDataFrameFunction(functionName);
         if (mapping === undefined) {
             return;
         }
         else if (mapping.type === 'entry_point') {
             return [{ operation: 'unknown', operand: undefined }];
         }
-        else if (mapping.type === 'transformation' || mapping.type === 'modification') {
+        else if (mapping.type === 'transformation') {
+            const args = (0, arguments_1.getFunctionArguments)(node, dfg);
+            return mapDataFrameUnknown(args, mapping, inference, resolveInfo) ?? (mapping.alwaysDataFrame ? [{ operation: 'unknown', operand: undefined }] : undefined);
+        }
+        else if (mapping.type === 'modification') {
             const args = (0, arguments_1.getFunctionArguments)(node, dfg);
-            return mapDataFrameUnknown(args, mapping, inference, resolveInfo);
+            return mapDataFrameUnknown(args, { ...mapping, constraintType: semantics_1.ConstraintType.OperandModification }, inference, resolveInfo);
         }
         else {
             (0, assert_1.assertUnreachable)(mapping);
@@ -873,7 +897,7 @@ function mapDataFrameSelect(args, params, inference, info) {
     const accessedCols = [...selectedCols ?? [], ...unselectedCols ?? []];
     const mixedAccess = accessedCols.some(col => typeof col === 'string') && accessedCols.some(col => typeof col === 'number');
     const duplicateAccess = accessedCols.some((col, _, list) => col !== undefined && list.filter(other => other === col).length > 1);
-    const renamedCols = selectArgs.some(arguments_1.isNamedArgument);
+    const renamedCols = selectArgs.some(r_argument_1.RArgument.isNamed);
     // map to top if columns are selected mixed by string and number, or are selected duplicate
     if (mixedAccess || duplicateAccess) {
         selectedCols = undefined;
@@ -974,8 +998,8 @@ function mapDataFrameGroupBy(args, params, inference, info) {
     const result = [];
     const byArgs = args.filter(arg => arg !== dataFrame);
     const accessedNames = byArgs.flatMap(arg => (0, arguments_1.getUnresolvedSymbolsInExpression)(arg, info.graph)).map(identifier_1.Identifier.toString);
-    const byNames = byArgs.map(arg => (0, arguments_1.isNamedArgument)(arg) ? (0, resolve_args_1.resolveIdToArgName)(arg, info) : (0, resolve_args_1.resolveIdToArgValueSymbolName)(arg, info));
-    const mutatedCols = byArgs.some(arguments_1.isNamedArgument) || byNames.some(assert_1.isUndefined);
+    const byNames = byArgs.map(arg => r_argument_1.RArgument.isNamed(arg) ? (0, resolve_args_1.resolveIdToArgName)(arg, info) : (0, resolve_args_1.resolveIdToArgValueSymbolName)(arg, info));
+    const mutatedCols = byArgs.some(r_argument_1.RArgument.isNamed) || byNames.some(assert_1.isUndefined);
     if (accessedNames.length > 0) {
         result.push({
             operation: 'accessCols',
@@ -1076,7 +1100,7 @@ function mapDataFrameIdentity(args, params, inference, info) {
     if (!(0, arguments_1.isDataFrameArgument)(dataFrame, inference)) {
         return;
     }
-    else if (params.disallowNamedArgs && args.some(arguments_1.isNamedArgument)) {
+    else if (params.disallowNamedArgs && args.some(r_argument_1.RArgument.isNamed)) {
         return [{ operation: 'unknown', operand: dataFrame.value.info.id }];
     }
     return [{
@@ -1125,21 +1149,23 @@ function getRequestFromRead(fileNameArg, textArg, params, info) {
     else if (textArg !== undefined && textArg !== r_function_call_1.EmptyArgument) {
         const text = (0, resolve_args_1.resolveIdToArgValue)(textArg, info);
         if (typeof text === 'string') {
-            source = text;
             request = (0, retriever_1.requestFromInput)((0, resolve_args_1.unescapeSpecialChars)(text));
         }
     }
-    request = request ? info.ctx.files.resolveRequest(request).r : undefined;
+    if (request?.request === 'file' && info.ctx.files.hasCached(request.content)) {
+        request = info.ctx.files.resolveRequest(request).r;
+    }
     return { source, request };
 }
 /**
  * Gets all entries from a line of a CSV file using a custom separator char, quote char, and comment char
  */
 function getEntriesFromCsvLine(line, sep = ',', quote = '"', comment = '', trim = true) {
+    sep = sep.length > 0 ? sep : '\\s'; // default to whitespace separator
     sep = (0, arguments_1.escapeRegExp)(sep, true); // only allow tokens like `\s`, `\t`, or `\n` in separator, quote, and comment chars
     quote = (0, arguments_1.escapeRegExp)(quote);
     comment = (0, arguments_1.escapeRegExp)(comment);
-    const quantifier = sep === '\\s' ? '+' : '*'; // do not allow unquoted empty entries in whitespace-sparated files
+    const quantifier = sep === '\\s' ? '+' : '*'; // do not allow unquoted empty entries in whitespace-separated files
     const LineCommentRegex = new RegExp(`[${comment}].*`);
     const CsvEntryRegex = new RegExp(`(?<=^|[${sep}])(?:[${quote}]((?:[^${quote}]|[${quote}]{2})*)[${quote}]|([^${sep}]${quantifier}))`, 'g');
     const DoubleQuoteRegex = new RegExp(`([${quote}])\\1`, 'g'); // regex for doubled quotes like `""` or `''`

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

@@ -4,6 +4,7 @@ exports.mapDataFrameReplacementFunction = mapDataFrameReplacementFunction;
 const config_1 = require("../../../config");
 const vertex_1 = require("../../../dataflow/graph/vertex");
 const make_argument_1 = require("../../../dataflow/internal/process/functions/call/argument/make-argument");
+const r_argument_1 = require("../../../r-bridge/lang-4.x/ast/model/nodes/r-argument");
 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 resolve_args_1 = require("../resolve-args");
@@ -107,7 +108,7 @@ function mapDataFrameNamedColumnAssignment(access, expression, inference, info)
 }
 function mapDataFrameIndexColRowAssignment(access, expression, inference, info) {
     const dataFrame = access.accessed;
-    const args = access.access;
+    const args = access.access.filter(arg => r_argument_1.RArgument.isEmpty(arg) || r_argument_1.RArgument.isUnnamed(arg));
     if (!(0, arguments_1.isDataFrameArgument)(dataFrame, inference) || args.every(arg => arg === r_function_call_1.EmptyArgument)) {
         return;
     }

package/abstract-interpretation/data-frame/semantics.d.ts

@@ -1,4 +1,4 @@
-import { DataFrameDomain } from './dataframe-domain';
+import type { DataFrameDomain } from './dataframe-domain';
 /**
  * Represents the different types of resulting constraints that are inferred by abstract data frame operations.
  */

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

@@ -6,7 +6,6 @@ exports.getConstraintType = getConstraintType;
 const assert_1 = require("../../util/assert");
 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.
  */
@@ -73,7 +72,7 @@ function applyCreateSemantics(value, { colnames, rows }) {
     const colnamesValue = setRange(colnames);
     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({
+    return value.create({
         colnames: value.colnames.create(colnamesValue),
         cols: value.cols.create(colsValue),
         rows: value.rows.create(rowsValue)
@@ -84,14 +83,14 @@ function applyReadSemantics(value, { colnames, rows }) {
 }
 function applyAccessColsSemantics(value, { columns }) {
     if (columns?.every(col => typeof col === 'string')) {
-        return new dataframe_domain_1.DataFrameDomain({
+        return value.create({
             colnames: value.colnames.union(setRange(columns)),
             cols: value.cols,
             rows: value.rows
         });
     }
     else if (columns?.every(col => typeof col === 'number')) {
-        return new dataframe_domain_1.DataFrameDomain({
+        return value.create({
             colnames: value.colnames,
             cols: columns.reduce((current, col) => current.max([col, col]), value.cols),
             rows: value.rows
@@ -101,7 +100,7 @@ function applyAccessColsSemantics(value, { columns }) {
 }
 function applyAccessRowsSemantics(value, { rows }) {
     if (rows !== undefined) {
-        return new dataframe_domain_1.DataFrameDomain({
+        return value.create({
             colnames: value.colnames,
             cols: value.cols,
             rows: rows.reduce((current, row) => current.max([row, row]), value.rows)
@@ -111,20 +110,20 @@ function applyAccessRowsSemantics(value, { rows }) {
 }
 function applyAssignColsSemantics(value, { columns }) {
     if (columns?.every(col => typeof col === 'string')) {
-        return new dataframe_domain_1.DataFrameDomain({
+        return value.create({
             colnames: value.colnames.union(setRange(columns)),
             cols: value.cols.add([0, columns.length]).max([columns.length, columns.length]),
             rows: value.rows
         });
     }
     else if (columns?.every(col => typeof col === 'number')) {
-        return new dataframe_domain_1.DataFrameDomain({
+        return value.create({
             colnames: value.colnames.widenUp(),
             cols: columns.reduce((current, col) => current.max([col, col]), value.cols),
             rows: value.rows
         });
     }
-    return new dataframe_domain_1.DataFrameDomain({
+    return value.create({
         colnames: value.colnames.widenUp(),
         cols: value.cols.widenUp(),
         rows: value.rows
@@ -132,13 +131,13 @@ function applyAssignColsSemantics(value, { columns }) {
 }
 function applyAssignRowsSemantics(value, { rows }) {
     if (rows !== undefined) {
-        return new dataframe_domain_1.DataFrameDomain({
+        return value.create({
             colnames: value.colnames,
             cols: value.cols,
             rows: rows.reduce((current, row) => current.max([row, row]), value.rows)
         });
     }
-    return new dataframe_domain_1.DataFrameDomain({
+    return value.create({
         colnames: value.colnames,
         cols: value.cols,
         rows: value.rows.widenUp()
@@ -146,21 +145,21 @@ function applyAssignRowsSemantics(value, { rows }) {
 }
 function applySetColNamesSemantics(value, { colnames }, options) {
     if (options?.partial) {
-        return new dataframe_domain_1.DataFrameDomain({
+        return value.create({
             colnames: value.colnames.widenDown().union(setRange(colnames)),
             cols: value.cols,
             rows: value.rows
         });
     }
     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({
+    return value.create({
         colnames: allColNames ? value.colnames.create(setRange(colnames)) : value.colnames.create(setRange(colnames)).widenUp(),
         cols: value.cols,
         rows: value.rows
     });
 }
 function applyAddColsSemantics(value, { colnames }) {
-    return new dataframe_domain_1.DataFrameDomain({
+    return value.create({
         colnames: colnames !== undefined ? value.colnames.union(setRange(colnames)) : value.colnames.widenUp(),
         cols: colnames !== undefined ? value.cols.add([colnames.length, colnames.length]) : value.cols.widenUp(),
         rows: value.rows
@@ -168,14 +167,13 @@ function applyAddColsSemantics(value, { colnames }) {
 }
 function applyAddRowsSemantics(value, { rows }) {
     if (value.cols.value !== lattice_1.Bottom && value.cols.value[0] === 0) {
-        return new dataframe_domain_1.DataFrameDomain({
-            ...value,
+        return value.create({
             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.widenUp()
         });
     }
-    return new dataframe_domain_1.DataFrameDomain({
+    return value.create({
         colnames: value.colnames,
         cols: value.cols,
         rows: rows !== undefined ? value.rows.add([rows, rows]) : value.rows.widenUp()
@@ -183,13 +181,13 @@ function applyAddRowsSemantics(value, { rows }) {
 }
 function applyRemoveColsSemantics(value, { colnames }, options) {
     if (options?.maybe) {
-        return new dataframe_domain_1.DataFrameDomain({
+        return value.create({
             colnames: colnames !== undefined ? value.colnames.subtract(setRange(colnames)) : value.colnames.widenDown(),
             cols: colnames !== undefined ? value.cols.subtract([colnames.length, 0]) : value.cols.widenDown(),
             rows: value.rows
         });
     }
-    return new dataframe_domain_1.DataFrameDomain({
+    return value.create({
         colnames: colnames !== undefined ? value.colnames.subtract(setRange(colnames)) : value.colnames.widenDown(),
         cols: colnames !== undefined ? value.cols.subtract([colnames.length, colnames.length]) : value.cols.widenDown(),
         rows: value.rows
@@ -197,20 +195,20 @@ function applyRemoveColsSemantics(value, { colnames }, options) {
 }
 function applyRemoveRowsSemantics(value, { rows }, options) {
     if (options?.maybe) {
-        return new dataframe_domain_1.DataFrameDomain({
+        return value.create({
             colnames: value.colnames,
             cols: value.cols,
             rows: rows !== undefined ? value.rows.subtract([rows, 0]) : value.rows.widenDown()
         });
     }
-    return new dataframe_domain_1.DataFrameDomain({
+    return value.create({
         colnames: value.colnames,
         cols: value.cols,
         rows: rows !== undefined ? value.rows.subtract([rows, rows]) : value.rows.widenDown()
     });
 }
 function applyConcatColsSemantics(value, { other }) {
-    return new dataframe_domain_1.DataFrameDomain({
+    return value.create({
         colnames: value.colnames.union(other.colnames),
         cols: value.cols.add(other.cols),
         rows: value.rows
@@ -218,14 +216,13 @@ function applyConcatColsSemantics(value, { other }) {
 }
 function applyConcatRowsSemantics(value, { other }) {
     if (value.cols.value !== lattice_1.Bottom && value.cols.value[0] === 0) {
-        return new dataframe_domain_1.DataFrameDomain({
-            ...value,
+        return value.create({
             colnames: value.colnames.join(other.colnames),
             cols: value.cols.join(other.cols),
             rows: value.rows.add(other.rows)
         });
     }
-    return new dataframe_domain_1.DataFrameDomain({
+    return value.create({
         colnames: value.colnames,
         cols: value.cols,
         rows: value.rows.add(other.rows)
@@ -233,20 +230,20 @@ function applyConcatRowsSemantics(value, { other }) {
 }
 function applySubsetColsSemantics(value, { colnames }, options) {
     if (options?.duplicateCols) {
-        return new dataframe_domain_1.DataFrameDomain({
+        return value.create({
             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 new dataframe_domain_1.DataFrameDomain({
+        return value.create({
             colnames: value.colnames.top(),
             cols: colnames !== undefined ? value.cols.min([colnames.length, colnames.length]) : value.cols.widenDown(),
             rows: value.rows
         });
     }
-    return new dataframe_domain_1.DataFrameDomain({
+    return value.create({
         colnames: colnames !== undefined ? value.colnames.intersect(setRange(colnames)) : value.colnames.widenDown(),
         cols: colnames !== undefined ? value.cols.min([colnames.length, colnames.length]) : value.cols.widenDown(),
         rows: value.rows
@@ -254,27 +251,27 @@ function applySubsetColsSemantics(value, { colnames }, options) {
 }
 function applySubsetRowsSemantics(value, { rows }, options) {
     if (options?.duplicateRows) {
-        return new dataframe_domain_1.DataFrameDomain({
+        return value.create({
             colnames: value.colnames,
             cols: value.cols,
             rows: rows !== undefined ? value.rows.create([rows, rows]) : value.rows.top()
         });
     }
-    return new dataframe_domain_1.DataFrameDomain({
+    return value.create({
         colnames: value.colnames,
         cols: value.cols,
         rows: rows !== undefined ? value.rows.min([rows, rows]) : value.rows.widenDown()
     });
 }
 function applyFilterRowsSemantics(value, { condition }) {
-    return new dataframe_domain_1.DataFrameDomain({
+    return value.create({
         colnames: value.colnames,
         cols: value.cols,
         rows: condition ? value.rows : condition === false ? value.rows.create([0, 0]) : value.rows.widenDown()
     });
 }
 function applyMutateColsSemantics(value, { colnames }) {
-    return new dataframe_domain_1.DataFrameDomain({
+    return value.create({
         colnames: colnames !== undefined ? value.colnames.union(setRange(colnames)) : value.colnames.widenUp(),
         cols: colnames !== undefined ? value.cols.add([0, colnames.length]).max([colnames.length, colnames.length]) : value.cols.widenUp(),
         rows: value.rows
@@ -282,7 +279,7 @@ function applyMutateColsSemantics(value, { colnames }) {
 }
 function applyGroupBySemantics(value, { by }, options) {
     if (options?.mutatedCols) {
-        return new dataframe_domain_1.DataFrameDomain({
+        return value.create({
             colnames: value.colnames.union(setRange(by)),
             cols: value.cols.add([0, by.length]),
             rows: value.rows
@@ -292,7 +289,7 @@ function applyGroupBySemantics(value, { by }, options) {
     return value;
 }
 function applySummarizeSemantics(value, { colnames }) {
-    return new dataframe_domain_1.DataFrameDomain({
+    return value.create({
         colnames: colnames !== undefined ? value.colnames.join(setRange([])).union(setRange(colnames)) : value.colnames.widenUp(),
         cols: colnames !== undefined ? value.cols.add([0, colnames.length]).min([colnames.length, +Infinity]) : value.cols.widenUp(),
         rows: value.rows.min([1, +Infinity]).max([0, 1])
@@ -360,8 +357,7 @@ function applyJoinSemantics(value, { other, by }, options) {
         default:
             (0, assert_1.assertUnreachable)(joinType);
     }
-    return new dataframe_domain_1.DataFrameDomain({
-        ...value,
+    return value.create({
         colnames: duplicateCols === undefined ? value.colnames.top() : duplicateCols.length > 0 ? value.colnames.union(other.colnames).subtract(setRange(duplicateCols)).widenUp() : value.colnames.union(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

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

@@ -16,7 +16,7 @@ class DataFrameShapeInferenceVisitor extends absint_visitor_1.AbstractInterpreta
      */
     operations;
     constructor({ trackOperations = true, ...config }) {
-        super(config);
+        super(config, dataframe_domain_1.DataFrameDomain.top());
         if (trackOperations) {
             this.operations = new Map();
         }

package/abstract-interpretation/domains/interval-domain.d.ts

@@ -65,5 +65,6 @@ export declare class IntervalDomain<Value extends IntervalLift = IntervalLift> e
     isTop(): this is IntervalDomain<IntervalTop>;
     isBottom(): this is IntervalDomain<IntervalBottom>;
     isValue(): this is IntervalDomain<IntervalValue>;
+    isFinite(): this is IntervalDomain<IntervalValue>;
 }
 export {};

package/abstract-interpretation/domains/interval-domain.js

@@ -259,6 +259,9 @@ class IntervalDomain extends abstract_domain_1.AbstractDomain {
     isValue() {
         return this.value !== lattice_1.Bottom;
     }
+    isFinite() {
+        return this.isValue() && Number.isFinite(this.value[0]) && Number.isFinite(this.value[1]);
+    }
 }
 exports.IntervalDomain = IntervalDomain;
 //# sourceMappingURL=interval-domain.js.map

package/abstract-interpretation/domains/product-domain.d.ts

@@ -13,6 +13,7 @@ export type ConcreteProduct<Product extends AbstractProduct> = {
  * @template Product - Type of the abstract product of the product domain mapping property names to abstract domains
  */
 export declare abstract class ProductDomain<Product extends AbstractProduct> extends AbstractDomain<ConcreteProduct<Product>, Product, Product, Product> {
+    constructor(value: Product);
     abstract create(value: Product): this;
     bottom(): this;
     top(): this;
@@ -26,7 +27,15 @@ export declare abstract class ProductDomain<Product extends AbstractProduct> ext
     abstract(concrete: ReadonlySet<ConcreteProduct<Product>> | typeof Top): this;
     toJson(): unknown;
     toString(): string;
+    isTop(): boolean;
     isTop(): this is this;
+    isBottom(): boolean;
     isBottom(): this is this;
+    isValue(): boolean;
     isValue(): this is this;
+    /**
+     * Optional reduction function for a reduced product domain.
+     */
+    protected reduce(value: Product): Product;
+    private refine;
 }