@eagleoutice/flowr 2.7.0 → 2.7.2

package/abstract-interpretation/data-frame/dataframe-domain.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataFrameStateDomain = exports.DataFrameDomain = void 0;
+const lattice_1 = require("../domains/lattice");
 const positive_interval_domain_1 = require("../domains/positive-interval-domain");
 const product_domain_1 = require("../domains/product-domain");
 const set_range_domain_1 = require("../domains/set-range-domain");
@@ -9,15 +10,15 @@ const state_abstract_domain_1 = require("../domains/state-abstract-domain");
  * The data frame abstract domain as product domain of a column names domain, column count domain, and row count domain.
  */
 class DataFrameDomain extends product_domain_1.ProductDomain {
-    constructor(value, maxColNames) {
-        super({
-            colnames: new set_range_domain_1.SetRangeDomain(value.colnames.value, maxColNames ?? value.colnames.limit),
-            cols: new positive_interval_domain_1.PosIntervalDomain(value.cols.value),
-            rows: new positive_interval_domain_1.PosIntervalDomain(value.rows.value)
-        });
+    constructor(value) {
+        super(DataFrameDomain.refine({
+            colnames: value.colnames.create(value.colnames.value),
+            cols: value.cols.create(value.cols.value),
+            rows: value.rows.create(value.rows.value)
+        }));
     }
     create(value) {
-        return new DataFrameDomain(value, this.colnames.limit);
+        return new DataFrameDomain(value);
     }
     /**
      * The current abstract value of the column names domain.
@@ -51,6 +52,21 @@ class DataFrameDomain extends product_domain_1.ProductDomain {
             rows: positive_interval_domain_1.PosIntervalDomain.top()
         });
     }
+    static refine(value) {
+        if (value.colnames.isValue() && value.cols.isValue()) {
+            if (value.colnames.value.range === lattice_1.Top && value.colnames.value.min.size >= value.cols.value[1]) {
+                value.colnames = value.colnames.meet({ min: new Set(), range: value.colnames.value.min });
+            }
+            if (value.colnames.isValue()) {
+                const minColNames = value.colnames.value.min.size;
+                const maxColNames = value.colnames.isFinite() ? value.colnames.value.min.size + value.colnames.value.range.size : Infinity;
+                if (minColNames > value.cols.value[0] || maxColNames < value.cols.value[1]) {
+                    value.cols = value.cols.meet([minColNames, maxColNames]);
+                }
+            }
+        }
+        return value;
+    }
 }
 exports.DataFrameDomain = DataFrameDomain;
 /**

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

@@ -1,17 +1,17 @@
 import type { DataflowGraph } from '../../../dataflow/graph/graph';
+import type { ReadOnlyFlowrAnalyzerContext } from '../../../project/context/flowr-analyzer-context';
 import type { RNode } from '../../../r-bridge/lang-4.x/ast/model/model';
 import type { RAccess, RNamedAccess } from '../../../r-bridge/lang-4.x/ast/model/nodes/r-access';
 import type { ParentInformation } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { DataFrameExpressionInfo } from '../absint-info';
-import type { ReadOnlyFlowrAnalyzerContext } from '../../../project/context/flowr-analyzer-context';
+import type { DataFrameOperations, DataFrameShapeInferenceVisitor } from '../shape-inference';
 /**
- * Maps a concrete data frame access to abstract data frame operations.
+ * Maps a concrete data frame access operation to abstract data frame operations.
  * @param node - The R node of the access
  * @param dfg  - The data flow graph for resolving the arguments
- * @param ctx  - The read-only Flowr analyzer context
- * @returns Data frame expression info containing the mapped abstract data frame operations, or `undefined` if the node does not represent a data frame access
+ * @param ctx  - The current flowR analyzer context
+ * @returns The mapped abstract data frame operations for the access operation, or `undefined` if the node does not represent a data frame access operation
  */
-export declare function mapDataFrameAccess(node: RNode<ParentInformation>, dfg: DataflowGraph, ctx: ReadOnlyFlowrAnalyzerContext): DataFrameExpressionInfo | undefined;
+export declare function mapDataFrameAccess(node: RNode<ParentInformation>, inference: DataFrameShapeInferenceVisitor, dfg: DataflowGraph, ctx: ReadOnlyFlowrAnalyzerContext): DataFrameOperations;
 /**
  * Checks whether an access node represents a string-based access (`$` or `@`), and no index-based access (`[` or `[[`).
  */

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

@@ -15,31 +15,27 @@ const SpecialAccessArgumentsMapper = {
     '[[': ['exact']
 };
 /**
- * Maps a concrete data frame access to abstract data frame operations.
+ * Maps a concrete data frame access operation to abstract data frame operations.
  * @param node - The R node of the access
  * @param dfg  - The data flow graph for resolving the arguments
- * @param ctx  - The read-only Flowr analyzer context
- * @returns Data frame expression info containing the mapped abstract data frame operations, or `undefined` if the node does not represent a data frame access
+ * @param ctx  - The current flowR analyzer context
+ * @returns The mapped abstract data frame operations for the access operation, or `undefined` if the node does not represent a data frame access operation
  */
-function mapDataFrameAccess(node, dfg, ctx) {
+function mapDataFrameAccess(node, inference, dfg, ctx) {
     if (node.type !== type_1.RType.Access) {
         return;
     }
     const resolveInfo = { graph: dfg, idMap: dfg.idMap, full: true, resolve: config_1.VariableResolve.Alias, ctx };
-    let operations;
     if (isStringBasedAccess(node)) {
-        operations = mapDataFrameNamedColumnAccess(node, resolveInfo);
+        return mapDataFrameNamedColumnAccess(node, inference, resolveInfo);
     }
     else {
-        operations = mapDataFrameIndexColRowAccess(node, resolveInfo);
-    }
-    if (operations !== undefined) {
-        return { type: 'expression', operations: operations };
+        return mapDataFrameIndexColRowAccess(node, inference, resolveInfo);
     }
 }
-function mapDataFrameNamedColumnAccess(access, info) {
+function mapDataFrameNamedColumnAccess(access, inference, info) {
     const dataFrame = access.accessed;
-    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, info)) {
+    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, inference)) {
         return;
     }
     const colname = (0, resolve_args_1.resolveIdToArgValueSymbolName)(access.access[0], info);
@@ -49,12 +45,12 @@ function mapDataFrameNamedColumnAccess(access, info) {
             columns: colname ? [colname] : undefined
         }];
 }
-function mapDataFrameIndexColRowAccess(access, info) {
+function mapDataFrameIndexColRowAccess(access, inference, info) {
     const dataFrame = access.accessed;
     const drop = (0, arguments_1.getArgumentValue)(access.access, 'drop', info);
     const exact = (0, arguments_1.getArgumentValue)(access.access, 'exact', info);
     const args = getAccessArgs(access.operator, access.access);
-    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, info)) {
+    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, inference)) {
         return;
     }
     else if (args.every(arg => arg === r_function_call_1.EmptyArgument)) {

package/abstract-interpretation/data-frame/mappers/arguments.d.ts

@@ -6,7 +6,7 @@ import { type RFunctionArgument, type RFunctionCall, EmptyArgument } from '../..
 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 { RNull } from '../../../r-bridge/lang-4.x/convert-values';
-import type { AbstractInterpretationInfo } from '../absint-info';
+import type { DataFrameShapeInferenceVisitor } from '../shape-inference';
 /**
  * The location of a function parameter for mapping function call arguments to function parameters.
  * - `pos` contains the position of the function parameter (use `-1` for non-existent or non-positional arguments)
@@ -31,9 +31,10 @@ export declare function escapeRegExp(text: string, allowTokens?: boolean): strin
  * @param checkNames   - Whether to map all invalid column names to top (`undefined`)
  * @param noDupNames   - Whether to map all duplicate column names to top (`undefined`)
  * @param noEmptyNames - Whether to map all empty column names to top (`undefined`)
+ * @param collapseDups - Whether duplicate columns should be collapsed to single occurrences afterward (excluding `undefined` values)
  * @returns The filtered column names
  */
-export declare function filterValidNames(colnames: (string | undefined)[] | undefined, checkNames?: boolean, noDupNames?: boolean, noEmptyNames?: boolean): (string | undefined)[] | undefined;
+export declare function filterValidNames(colnames: (string | undefined)[] | undefined, checkNames?: boolean, noDupNames?: boolean, noEmptyNames?: boolean, collapseDups?: boolean): (string | undefined)[] | undefined;
 /**
  * Gets the value of an argument that specified as {@link FunctionParameterLocation}.
  * @param args     - The arguments to get the requested argument from
@@ -80,14 +81,14 @@ export declare function getUnresolvedSymbolsInExpression(expression: RNode<Paren
  */
 export declare function hasCriticalArgument(args: readonly RFunctionArgument<ParentInformation>[], critical: (FunctionParameterLocation<unknown> | string)[] | undefined, info: ResolveInfo): boolean;
 /**
- * Checks if a given argument has any data frame shape information and therefore may represent a data frame.
- * @param arg  - The argument to check
- * @param info - Argument resolve information
- * @returns Whether the argument has any data frame shape information and may represent a data frame
+ * Checks if a given argument has an inferred data frame shape and therefore represents a data frame
+ * @param arg       - The argument to check
+ * @param inference - The data frame shape inference visitor to use
+ * @returns Whether the argument represents a data frame
  */
-export declare function isDataFrameArgument(arg: RNode<ParentInformation> | undefined, info: ResolveInfo): arg is RNode<ParentInformation & Required<AbstractInterpretationInfo>>;
-export declare function isDataFrameArgument(arg: RFunctionArgument<ParentInformation> | undefined, info: ResolveInfo): arg is RArgument<ParentInformation & Required<AbstractInterpretationInfo>> & {
-    value: RNode<ParentInformation & Required<AbstractInterpretationInfo>>;
+export declare function isDataFrameArgument(arg: RNode<ParentInformation> | undefined, inference: DataFrameShapeInferenceVisitor): arg is RNode<ParentInformation>;
+export declare function isDataFrameArgument(arg: RFunctionArgument<ParentInformation> | undefined, inference: DataFrameShapeInferenceVisitor): arg is RArgument<ParentInformation> & {
+    value: RNode<ParentInformation>;
 };
 /**
  * Checks whether a function argument is a names argument.

package/abstract-interpretation/data-frame/mappers/arguments.js

@@ -19,7 +19,6 @@ const visitor_1 = require("../../../r-bridge/lang-4.x/ast/model/processing/visit
 const type_1 = require("../../../r-bridge/lang-4.x/ast/model/type");
 const convert_values_1 = require("../../../r-bridge/lang-4.x/convert-values");
 const resolve_args_1 = require("../resolve-args");
-const shape_inference_1 = require("../shape-inference");
 /** Regular expression representing valid columns names, e.g. for `data.frame` */
 const ColNamesRegex = /^[A-Za-z.][A-Za-z0-9_.]*$/;
 /**
@@ -42,9 +41,10 @@ function escapeRegExp(text, allowTokens = false) {
  * @param checkNames   - Whether to map all invalid column names to top (`undefined`)
  * @param noDupNames   - Whether to map all duplicate column names to top (`undefined`)
  * @param noEmptyNames - Whether to map all empty column names to top (`undefined`)
+ * @param collapseDups - Whether duplicate columns should be collapsed to single occurrences afterward (excluding `undefined` values)
  * @returns The filtered column names
  */
-function filterValidNames(colnames, checkNames, noDupNames, noEmptyNames) {
+function filterValidNames(colnames, checkNames, noDupNames, noEmptyNames, collapseDups = false) {
     if (checkNames) { // map all invalid column names to top
         colnames = colnames?.map(entry => isValidColName(entry) ? entry : undefined);
     }
@@ -54,6 +54,9 @@ function filterValidNames(colnames, checkNames, noDupNames, noEmptyNames) {
     if (noEmptyNames) { // map all empty column names to top
         colnames = colnames?.map(entry => entry?.length === 0 ? undefined : entry);
     }
+    if (collapseDups) {
+        colnames = colnames?.filter((value, index, array) => value === undefined || array.indexOf(value) === index);
+    }
     return colnames;
 }
 /**
@@ -157,8 +160,8 @@ function hasCriticalArgument(args, critical, info) {
     }
     return false;
 }
-function isDataFrameArgument(arg, info) {
-    return arg !== r_function_call_1.EmptyArgument && (0, shape_inference_1.resolveIdToDataFrameShape)(arg, info.graph) !== undefined;
+function isDataFrameArgument(arg, inference) {
+    return arg !== r_function_call_1.EmptyArgument && inference.getAbstractValue(arg) !== undefined;
 }
 /**
  * Checks whether a function argument is a names argument.

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

@@ -4,7 +4,7 @@ import type { ReadOnlyFlowrAnalyzerContext } from '../../../project/context/flow
 import type { RNode } from '../../../r-bridge/lang-4.x/ast/model/model';
 import { type RFunctionArgument } from '../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { ParentInformation } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { DataFrameExpressionInfo, DataFrameOperation } from '../absint-info';
+import type { DataFrameOperations, DataFrameShapeInferenceVisitor } from '../shape-inference';
 import { type FunctionParameterLocation } from './arguments';
 /**
  * Represents the different types of data frames in R
@@ -182,17 +182,17 @@ type DataFrameFunction = keyof typeof DataFrameFunctionMapper;
  * @param node - The R node of the function call
  * @param dfg  - The data flow graph for resolving the arguments
  * @param ctx  - The current flowR analyzer context
- * @returns Data frame expression info containing the mapped abstract data frame operations, or `undefined` if the node does not represent a data frame function call
+ * @returns The mapped abstract data frame operations for the function call, or `undefined` if the node does not represent a data frame function call
  */
-export declare function mapDataFrameFunctionCall<Name extends DataFrameFunction>(node: RNode<ParentInformation>, dfg: DataflowGraph, ctx: ReadOnlyFlowrAnalyzerContext): DataFrameExpressionInfo | undefined;
+export declare function mapDataFrameFunctionCall<Name extends DataFrameFunction>(node: RNode<ParentInformation>, inference: DataFrameShapeInferenceVisitor, dfg: DataflowGraph, ctx: ReadOnlyFlowrAnalyzerContext): DataFrameOperations;
 declare function mapDataFrameCreate(args: readonly RFunctionArgument<ParentInformation>[], params: {
     checkNames: FunctionParameterLocation<boolean>;
     noDupNames: FunctionParameterLocation<boolean>;
     special: string[];
-}, info: ResolveInfo): DataFrameOperation[];
+}, inference: DataFrameShapeInferenceVisitor, info: ResolveInfo): DataFrameOperations;
 declare function mapDataFrameConvert(args: readonly RFunctionArgument<ParentInformation>[], params: {
     dataFrame: FunctionParameterLocation;
-}, info: ResolveInfo): DataFrameOperation[] | undefined;
+}, inference: DataFrameShapeInferenceVisitor, info: ResolveInfo): DataFrameOperations;
 declare function mapDataFrameRead(args: readonly RFunctionArgument<ParentInformation>[], params: {
     fileName: FunctionParameterLocation;
     text?: FunctionParameterLocation;
@@ -204,46 +204,46 @@ declare function mapDataFrameRead(args: readonly RFunctionArgument<ParentInforma
     checkNames: FunctionParameterLocation<boolean>;
     noDupNames: FunctionParameterLocation<boolean>;
     noEmptyNames?: boolean;
-}, info: ResolveInfo, ctx: ReadOnlyFlowrAnalyzerContext): DataFrameOperation[];
+}, inference: DataFrameShapeInferenceVisitor, info: ResolveInfo): DataFrameOperations;
 declare function mapDataFrameColBind(args: readonly RFunctionArgument<ParentInformation>[], params: {
     special: string[];
-}, info: ResolveInfo): DataFrameOperation[] | undefined;
+}, inference: DataFrameShapeInferenceVisitor, info: ResolveInfo): DataFrameOperations;
 declare function mapDataFrameRowBind(args: readonly RFunctionArgument<ParentInformation>[], params: {
     special: string[];
-}, info: ResolveInfo): DataFrameOperation[] | undefined;
+}, inference: DataFrameShapeInferenceVisitor, info: ResolveInfo): DataFrameOperations;
 declare function mapDataFrameHeadTail(args: readonly RFunctionArgument<ParentInformation>[], params: {
     dataFrame: FunctionParameterLocation;
     amount: FunctionParameterLocation<number>;
-}, info: ResolveInfo): DataFrameOperation[] | undefined;
+}, inference: DataFrameShapeInferenceVisitor, info: ResolveInfo): DataFrameOperations;
 declare function mapDataFrameSubset(args: readonly RFunctionArgument<ParentInformation>[], params: {
     dataFrame: FunctionParameterLocation;
     subset: FunctionParameterLocation;
     select: FunctionParameterLocation;
     drop: FunctionParameterLocation<boolean>;
-}, info: ResolveInfo): DataFrameOperation[] | undefined;
+}, inference: DataFrameShapeInferenceVisitor, info: ResolveInfo): DataFrameOperations;
 declare function mapDataFrameFilter(args: readonly RFunctionArgument<ParentInformation>[], params: {
     dataFrame: FunctionParameterLocation;
     special: string[];
-}, info: ResolveInfo): DataFrameOperation[] | undefined;
+}, inference: DataFrameShapeInferenceVisitor, info: ResolveInfo): DataFrameOperations;
 declare function mapDataFrameSelect(args: readonly RFunctionArgument<ParentInformation>[], params: {
     dataFrame: FunctionParameterLocation;
     special: string[];
-}, info: ResolveInfo): DataFrameOperation[] | undefined;
+}, inference: DataFrameShapeInferenceVisitor, info: ResolveInfo): DataFrameOperations;
 declare function mapDataFrameMutate(args: readonly RFunctionArgument<ParentInformation>[], params: {
     dataFrame: FunctionParameterLocation;
     special: string[];
     checkNames?: boolean;
     noDupNames?: boolean;
-}, info: ResolveInfo): DataFrameOperation[] | undefined;
+}, inference: DataFrameShapeInferenceVisitor, info: ResolveInfo): DataFrameOperations;
 declare function mapDataFrameGroupBy(args: readonly RFunctionArgument<ParentInformation>[], params: {
     dataFrame: FunctionParameterLocation;
     by: FunctionParameterLocation;
     special: string[];
-}, info: ResolveInfo): DataFrameOperation[] | undefined;
+}, inference: DataFrameShapeInferenceVisitor, info: ResolveInfo): DataFrameOperations;
 declare function mapDataFrameSummarize(args: readonly RFunctionArgument<ParentInformation>[], params: {
     dataFrame: FunctionParameterLocation;
     special: string[];
-}, info: ResolveInfo): DataFrameOperation[] | undefined;
+}, inference: DataFrameShapeInferenceVisitor, info: ResolveInfo): DataFrameOperations;
 declare function mapDataFrameJoin(args: readonly RFunctionArgument<ParentInformation>[], params: {
     dataFrame: FunctionParameterLocation;
     otherDataFrame: FunctionParameterLocation;
@@ -251,10 +251,10 @@ declare function mapDataFrameJoin(args: readonly RFunctionArgument<ParentInforma
     joinAll: FunctionParameterLocation<boolean>;
     joinLeft: FunctionParameterLocation<boolean>;
     joinRight: FunctionParameterLocation<boolean>;
-}, info: ResolveInfo, ctx: ReadOnlyFlowrAnalyzerContext): DataFrameOperation[] | undefined;
+}, inference: DataFrameShapeInferenceVisitor, info: ResolveInfo): DataFrameOperations;
 declare function mapDataFrameIdentity(args: readonly RFunctionArgument<ParentInformation>[], params: {
     dataFrame: FunctionParameterLocation;
     special: string[];
     disallowNamedArgs?: boolean;
-}, info: ResolveInfo): DataFrameOperation[] | undefined;
+}, inference: DataFrameShapeInferenceVisitor, info: ResolveInfo): DataFrameOperations;
 export {};

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

@@ -11,7 +11,6 @@ const assert_1 = require("../../../util/assert");
 const files_1 = require("../../../util/files");
 const dataframe_domain_1 = require("../dataframe-domain");
 const resolve_args_1 = require("../resolve-args");
-const shape_inference_1 = require("../shape-inference");
 const arguments_1 = require("./arguments");
 /**
  * Represents the different types of data frames in R
@@ -522,24 +521,23 @@ const DataFrameFunctionParamsMapper = {
  * @param node - The R node of the function call
  * @param dfg  - The data flow graph for resolving the arguments
  * @param ctx  - The current flowR analyzer context
- * @returns Data frame expression info containing the mapped abstract data frame operations, or `undefined` if the node does not represent a data frame function call
+ * @returns The mapped abstract data frame operations for the function call, or `undefined` if the node does not represent a data frame function call
  */
-function mapDataFrameFunctionCall(node, dfg, ctx) {
+function mapDataFrameFunctionCall(node, inference, dfg, ctx) {
     if (node.type !== type_1.RType.FunctionCall || !node.named) {
         return;
     }
     const resolveInfo = { graph: dfg, idMap: dfg.idMap, full: true, resolve: config_1.VariableResolve.Alias, ctx };
-    let operations;
     if (isDataFrameFunction(node.functionName.content)) {
         const functionName = node.functionName.content;
         const mapper = DataFrameFunctionMapper[functionName].mapper;
         const params = DataFrameFunctionParamsMapper[functionName];
         const args = (0, arguments_1.getFunctionArguments)(node, dfg);
         if ((0, arguments_1.hasCriticalArgument)(args, params.critical, resolveInfo)) {
-            operations = [{ operation: 'unknown', operand: undefined }];
+            return [{ operation: 'unknown', operand: undefined }];
         }
         else {
-            operations = mapper(args, params, resolveInfo, ctx);
+            return mapper(args, params, inference, resolveInfo);
         }
     }
     else {
@@ -548,19 +546,16 @@ function mapDataFrameFunctionCall(node, dfg, ctx) {
             return;
         }
         else if (mapping.type === 'entry_point') {
-            operations = [{ operation: 'unknown', operand: undefined }];
+            return [{ operation: 'unknown', operand: undefined }];
         }
         else if (mapping.type === 'transformation' || mapping.type === 'modification') {
             const args = (0, arguments_1.getFunctionArguments)(node, dfg);
-            operations = mapDataFrameUnknown(args, mapping, resolveInfo);
+            return mapDataFrameUnknown(args, mapping, inference, resolveInfo);
         }
         else {
             (0, assert_1.assertUnreachable)(mapping);
         }
     }
-    if (operations !== undefined) {
-        return { type: 'expression', operations };
-    }
 }
 function isDataFrameFunction(functionName) {
     // a check with `functionName in DataFrameFunctionMapper` would return true for "toString"
@@ -569,7 +564,7 @@ function isDataFrameFunction(functionName) {
 function getOtherDataFrameFunction(functionName) {
     return OtherDataFrameFunctions.find(entry => entry.names.includes(functionName));
 }
-function mapDataFrameCreate(args, params, info) {
+function mapDataFrameCreate(args, params, inference, info) {
     const checkNames = (0, arguments_1.getArgumentValue)(args, params.checkNames, info);
     const noDupNames = (0, arguments_1.getArgumentValue)(args, params.noDupNames, info);
     args = (0, arguments_1.getEffectiveArgs)(args, params.special);
@@ -595,7 +590,7 @@ function mapDataFrameCreate(args, params, info) {
             rows
         }];
 }
-function mapDataFrameConvert(args, params, info) {
+function mapDataFrameConvert(args, params, inference, info) {
     const dataFrame = (0, arguments_1.getFunctionArgument)(args, params.dataFrame, info);
     if (dataFrame === r_function_call_1.EmptyArgument || dataFrame?.value === undefined) {
         return [{ operation: 'unknown', operand: undefined }];
@@ -605,10 +600,10 @@ function mapDataFrameConvert(args, params, info) {
             operand: dataFrame.value.info.id
         }];
 }
-function mapDataFrameRead(args, params, info, ctx) {
+function mapDataFrameRead(args, params, inference, info) {
     const fileNameArg = (0, arguments_1.getFunctionArgument)(args, params.fileName, info);
     const textArg = params.text ? (0, arguments_1.getFunctionArgument)(args, params.text, info) : undefined;
-    const { source, request } = getRequestFromRead(fileNameArg, textArg, params, info, ctx);
+    const { source, request } = getRequestFromRead(fileNameArg, textArg, params, info);
     const header = (0, arguments_1.getArgumentValue)(args, params.header, info);
     const separator = (0, arguments_1.getArgumentValue)(args, params.separator, info);
     const quote = (0, arguments_1.getArgumentValue)(args, params.quote, info);
@@ -618,7 +613,7 @@ function mapDataFrameRead(args, params, info, ctx) {
     const noDupNames = (0, arguments_1.getArgumentValue)(args, params.noDupNames, info);
     const validArguments = typeof header === 'boolean' && typeof separator === 'string' && typeof quote === 'string' && typeof comment === 'string' &&
         typeof skipLines === 'number' && typeof checkNames === 'boolean' && typeof noDupNames === 'boolean';
-    if (request === undefined || !ctx.config.abstractInterpretation.dataFrame.readLoadedData.readExternalFiles || !validArguments) {
+    if (request === undefined || !info.ctx.config.abstractInterpretation.dataFrame.readLoadedData.readExternalFiles || !validArguments) {
         return [{
                 operation: 'read',
                 operand: undefined,
@@ -643,7 +638,7 @@ function mapDataFrameRead(args, params, info, ctx) {
             }
         }
     };
-    const allLines = parseRequestContent(request, parseLine, ctx.config.abstractInterpretation.dataFrame.readLoadedData.maxReadLines);
+    const allLines = parseRequestContent(request, parseLine, info.ctx.config.abstractInterpretation.dataFrame.readLoadedData.maxReadLines);
     let colnames;
     if (header) {
         colnames = (0, arguments_1.filterValidNames)(firstLine, checkNames, noDupNames, params.noEmptyNames);
@@ -659,9 +654,9 @@ function mapDataFrameRead(args, params, info, ctx) {
             rows: allLines ? rowCount : [rowCount, Infinity]
         }];
 }
-function mapDataFrameColBind(args, params, info) {
+function mapDataFrameColBind(args, params, inference, info) {
     args = (0, arguments_1.getEffectiveArgs)(args, params.special);
-    const dataFrame = args.find(arg => (0, arguments_1.isDataFrameArgument)(arg, info));
+    const dataFrame = args.find(arg => (0, arguments_1.isDataFrameArgument)(arg, inference));
     if (dataFrame === undefined) {
         return;
     }
@@ -673,7 +668,7 @@ function mapDataFrameColBind(args, params, info) {
     let colnames = [];
     for (const arg of args) {
         if (arg !== dataFrame && arg !== r_function_call_1.EmptyArgument) {
-            const otherDataFrame = (0, shape_inference_1.resolveIdToDataFrameShape)(arg.value, info.graph);
+            const otherDataFrame = inference.getAbstractValue(arg.value);
             if (otherDataFrame !== undefined) {
                 result.push({
                     operation: 'concatCols',
@@ -701,9 +696,9 @@ function mapDataFrameColBind(args, params, info) {
     }
     return result;
 }
-function mapDataFrameRowBind(args, params, info) {
+function mapDataFrameRowBind(args, params, inference, info) {
     args = (0, arguments_1.getEffectiveArgs)(args, params.special);
-    const dataFrame = args.find(arg => (0, arguments_1.isDataFrameArgument)(arg, info));
+    const dataFrame = args.find(arg => (0, arguments_1.isDataFrameArgument)(arg, inference));
     if (dataFrame === undefined) {
         return;
     }
@@ -715,7 +710,7 @@ function mapDataFrameRowBind(args, params, info) {
     let rows = 0;
     for (const arg of args) {
         if (arg !== dataFrame && arg !== r_function_call_1.EmptyArgument) {
-            const otherDataFrame = (0, shape_inference_1.resolveIdToDataFrameShape)(arg.value, info.graph);
+            const otherDataFrame = inference.getAbstractValue(arg.value);
             if (otherDataFrame !== undefined) {
                 result.push({
                     operation: 'concatRows',
@@ -742,9 +737,9 @@ function mapDataFrameRowBind(args, params, info) {
     }
     return result;
 }
-function mapDataFrameHeadTail(args, params, info) {
+function mapDataFrameHeadTail(args, params, inference, info) {
     const dataFrame = (0, arguments_1.getFunctionArgument)(args, params.dataFrame, info);
-    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, info)) {
+    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, inference)) {
         return;
     }
     const result = [];
@@ -772,9 +767,9 @@ function mapDataFrameHeadTail(args, params, info) {
     }
     return result;
 }
-function mapDataFrameSubset(args, params, info) {
+function mapDataFrameSubset(args, params, inference, info) {
     const dataFrame = (0, arguments_1.getFunctionArgument)(args, params.dataFrame, info);
-    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, info)) {
+    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, inference)) {
         return;
     }
     else if (args.length === 1) {
@@ -835,10 +830,10 @@ function mapDataFrameSubset(args, params, info) {
     }
     return result;
 }
-function mapDataFrameFilter(args, params, info) {
+function mapDataFrameFilter(args, params, inference, info) {
     args = (0, arguments_1.getEffectiveArgs)(args, params.special);
     const dataFrame = (0, arguments_1.getFunctionArgument)(args, params.dataFrame, info);
-    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, info)) {
+    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, inference)) {
         return;
     }
     else if (args.length === 1) {
@@ -863,10 +858,10 @@ function mapDataFrameFilter(args, params, info) {
     });
     return result;
 }
-function mapDataFrameSelect(args, params, info) {
+function mapDataFrameSelect(args, params, inference, info) {
     args = (0, arguments_1.getEffectiveArgs)(args, params.special);
     const dataFrame = (0, arguments_1.getFunctionArgument)(args, params.dataFrame, info);
-    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, info)) {
+    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, inference)) {
         return;
     }
     const result = [];
@@ -915,10 +910,10 @@ function mapDataFrameSelect(args, params, info) {
     }
     return result;
 }
-function mapDataFrameMutate(args, params, info) {
+function mapDataFrameMutate(args, params, inference, info) {
     args = (0, arguments_1.getEffectiveArgs)(args, params.special);
     const dataFrame = (0, arguments_1.getFunctionArgument)(args, params.dataFrame, info);
-    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, info)) {
+    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, inference)) {
         return;
     }
     else if (args.length === 1) {
@@ -937,8 +932,8 @@ function mapDataFrameMutate(args, params, info) {
     const accessedNames = mutateArgs
         .flatMap(arg => (0, arguments_1.getUnresolvedSymbolsInExpression)(arg, info.graph))
         .filter(arg => !mutatedCols?.includes(arg));
-    deletedCols = (0, arguments_1.filterValidNames)(deletedCols, params.checkNames, params.noDupNames);
-    mutatedCols = (0, arguments_1.filterValidNames)(mutatedCols, params.checkNames, params.noDupNames);
+    deletedCols = (0, arguments_1.filterValidNames)(deletedCols, params.checkNames, params.noDupNames, undefined, true);
+    mutatedCols = (0, arguments_1.filterValidNames)(mutatedCols, params.checkNames, params.noDupNames, undefined, true);
     if (accessedNames.length > 0) {
         result.push({
             operation: 'accessCols',
@@ -965,10 +960,10 @@ function mapDataFrameMutate(args, params, info) {
     }
     return result;
 }
-function mapDataFrameGroupBy(args, params, info) {
+function mapDataFrameGroupBy(args, params, inference, info) {
     args = (0, arguments_1.getEffectiveArgs)(args, params.special);
     const dataFrame = (0, arguments_1.getFunctionArgument)(args, params.dataFrame, info);
-    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, info)) {
+    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, inference)) {
         return;
     }
     else if (args.length === 1) {
@@ -994,10 +989,10 @@ function mapDataFrameGroupBy(args, params, info) {
     });
     return result;
 }
-function mapDataFrameSummarize(args, params, info) {
+function mapDataFrameSummarize(args, params, inference, info) {
     args = (0, arguments_1.getEffectiveArgs)(args, params.special);
     const dataFrame = (0, arguments_1.getFunctionArgument)(args, params.dataFrame, info);
-    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, info)) {
+    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, inference)) {
         return;
     }
     const result = [];
@@ -1021,12 +1016,12 @@ function mapDataFrameSummarize(args, params, info) {
     });
     return result;
 }
-function mapDataFrameJoin(args, params, info, ctx) {
+function mapDataFrameJoin(args, params, inference, info) {
     const dataFrame = (0, arguments_1.getFunctionArgument)(args, params.dataFrame, info);
     const joinAll = (0, arguments_1.getArgumentValue)(args, params.joinAll, info);
     const joinLeft = (0, arguments_1.getArgumentValue)(args, params.joinLeft, info);
     const joinRight = (0, arguments_1.getArgumentValue)(args, params.joinRight, info);
-    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, info)) {
+    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, inference)) {
         return;
     }
     else if (args.length === 1) {
@@ -1038,7 +1033,7 @@ function mapDataFrameJoin(args, params, info, ctx) {
     const result = [];
     const otherArg = (0, arguments_1.getFunctionArgument)(args, params.otherDataFrame, info);
     const byArg = (0, arguments_1.getFunctionArgument)(args, params.by, info);
-    const otherDataFrame = (0, shape_inference_1.resolveIdToDataFrameShape)(otherArg, info.graph) ?? dataframe_domain_1.DataFrameDomain.top(ctx.config.abstractInterpretation.dataFrame.maxColNames);
+    const otherDataFrame = inference.getAbstractValue(otherArg) ?? dataframe_domain_1.DataFrameDomain.top(info.ctx.config.abstractInterpretation.dataFrame.maxColNames);
     let byCols;
     const joinType = getJoinType(joinAll, joinLeft, joinRight);
     if (byArg !== undefined) {
@@ -1073,10 +1068,10 @@ function mapDataFrameJoin(args, params, info, ctx) {
     });
     return result;
 }
-function mapDataFrameIdentity(args, params, info) {
+function mapDataFrameIdentity(args, params, inference, info) {
     args = (0, arguments_1.getEffectiveArgs)(args, params.special);
     const dataFrame = (0, arguments_1.getFunctionArgument)(args, params.dataFrame, info);
-    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, info)) {
+    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, inference)) {
         return;
     }
     else if (params.disallowNamedArgs && args.some(arguments_1.isNamedArgument)) {
@@ -1087,15 +1082,15 @@ function mapDataFrameIdentity(args, params, info) {
             operand: dataFrame.value.info.id
         }];
 }
-function mapDataFrameUnknown(args, params, info) {
+function mapDataFrameUnknown(args, params, inference, info) {
     let dataFrame;
     if (params.dataFrame !== undefined) {
         dataFrame = (0, arguments_1.getFunctionArgument)(args, params.dataFrame, info);
     }
     else {
-        dataFrame = args.find(arg => (0, arguments_1.isDataFrameArgument)(arg, info));
+        dataFrame = args.find(arg => (0, arguments_1.isDataFrameArgument)(arg, inference));
     }
-    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, info)) {
+    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, inference)) {
         return;
     }
     return [{
@@ -1104,7 +1099,7 @@ function mapDataFrameUnknown(args, params, info) {
             ...(params.constraintType !== undefined ? { type: params.constraintType } : {})
         }];
 }
-function getRequestFromRead(fileNameArg, textArg, params, info, ctx) {
+function getRequestFromRead(fileNameArg, textArg, params, info) {
     let source;
     let request;
     if (fileNameArg !== undefined && fileNameArg !== r_function_call_1.EmptyArgument) {
@@ -1112,7 +1107,7 @@ function getRequestFromRead(fileNameArg, textArg, params, info, ctx) {
         if (typeof fileName === 'string') {
             source = fileName;
             const referenceChain = fileNameArg.info.file ? [fileNameArg.info.file] : [];
-            const sources = (0, built_in_source_1.findSource)(ctx.config.solver.resolveSource, fileName, { referenceChain, ctx });
+            const sources = (0, built_in_source_1.findSource)(info.ctx.config.solver.resolveSource, fileName, { referenceChain, ctx: info.ctx });
             if (sources?.length === 1) {
                 source = sources[0];
                 // create request from resolved source file path
@@ -1131,7 +1126,7 @@ function getRequestFromRead(fileNameArg, textArg, params, info, ctx) {
             request = (0, retriever_1.requestFromInput)((0, resolve_args_1.unescapeSpecialChars)(text));
         }
     }
-    request = request ? ctx.files.resolveRequest(request).r : undefined;
+    request = request ? info.ctx.files.resolveRequest(request).r : undefined;
     return { source, request };
 }
 function parseRequestContent(request, parser, maxLines) {