@eagleoutice/flowr 2.6.3 → 2.7.2

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 };
-    let operations;
+    const resolveInfo = { graph: dfg, idMap: dfg.idMap, full: true, resolve: config_1.VariableResolve.Alias, ctx };
     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',
@@ -946,29 +941,29 @@ function mapDataFrameMutate(args, params, info) {
             columns: accessedNames
         });
     }
-    if (deletedCols === undefined || deletedCols.length > 0) {
+    if (mutatedCols === undefined || mutatedCols.length > 0 || deletedCols?.length === 0) {
         result.push({
-            operation: 'removeCols',
+            operation: 'mutateCols',
             operand: operand?.info.id,
-            colnames: deletedCols,
-            options: { maybe: true }
+            colnames: mutatedCols
         });
         operand = undefined;
     }
-    if (mutatedCols === undefined || mutatedCols.length > 0 || deletedCols?.length === 0) {
+    if (deletedCols === undefined || deletedCols.length > 0) {
         result.push({
-            operation: 'mutateCols',
+            operation: 'removeCols',
             operand: operand?.info.id,
-            colnames: mutatedCols
+            colnames: deletedCols,
+            options: { maybe: true }
         });
         operand = undefined;
     }
     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) {

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

@@ -1,11 +1,13 @@
 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 { ParentInformation } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { DataFrameExpressionInfo } from '../absint-info';
+import type { DataFrameOperations, DataFrameShapeInferenceVisitor } from '../shape-inference';
 /**
- * Maps a concrete data frame replacement function to abstract data frame operations.
- * @param node - The R node of the replacement function
+ * Maps a concrete data frame replacement function call to abstract data frame operations.
+ * @param node - The R node of the replacement function call
  * @param dfg  - The data flow graph for resolving the arguments
- * @returns Data frame expression info containing the mapped abstract data frame operations, or `undefined` if the node does not represent a data frame replacement function
+ * @param ctx - The current flowR analysis context
+ * @returns The mapped abstract data frame operations for the replacement function call, or `undefined` if the node does not represent a data frame replacement function call
  */
-export declare function mapDataFrameReplacementFunction(node: RNode<ParentInformation>, expression: RNode<ParentInformation>, dfg: DataflowGraph): DataFrameExpressionInfo | undefined;
+export declare function mapDataFrameReplacementFunction(node: RNode<ParentInformation>, expression: RNode<ParentInformation>, inference: DataFrameShapeInferenceVisitor, dfg: DataflowGraph, ctx: ReadOnlyFlowrAnalyzerContext): DataFrameOperations;

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

@@ -18,39 +18,36 @@ const DataFrameReplacementFunctionMapper = {
     'dimnames': mapDataFrameDimNamesAssignment
 };
 /**
- * Maps a concrete data frame replacement function to abstract data frame operations.
- * @param node - The R node of the replacement function
+ * Maps a concrete data frame replacement function call to abstract data frame operations.
+ * @param node - The R node of the replacement function call
  * @param dfg  - The data flow graph for resolving the arguments
- * @returns Data frame expression info containing the mapped abstract data frame operations, or `undefined` if the node does not represent a data frame replacement function
+ * @param ctx - The current flowR analysis context
+ * @returns The mapped abstract data frame operations for the replacement function call, or `undefined` if the node does not represent a data frame replacement function call
  */
-function mapDataFrameReplacementFunction(node, expression, dfg) {
+function mapDataFrameReplacementFunction(node, expression, inference, dfg, ctx) {
     const parent = hasParentReplacement(node, dfg) ? dfg.idMap?.get(node.info.parent) : undefined;
-    const resolveInfo = { graph: dfg, idMap: dfg.idMap, full: true, resolve: config_1.VariableResolve.Alias };
-    let operations;
+    const resolveInfo = { graph: dfg, idMap: dfg.idMap, full: true, resolve: config_1.VariableResolve.Alias, ctx };
     if (node.type === type_1.RType.Access) {
         if (node.access.every(arg => arg === r_function_call_1.EmptyArgument)) {
-            operations = mapDataFrameContentAssignment(node, expression, resolveInfo);
+            return mapDataFrameContentAssignment(node, expression, inference);
         }
         else if ((0, access_mapper_1.isStringBasedAccess)(node)) {
-            operations = mapDataFrameNamedColumnAssignment(node, expression, resolveInfo);
+            return mapDataFrameNamedColumnAssignment(node, expression, inference, resolveInfo);
         }
         else {
-            operations = mapDataFrameIndexColRowAssignment(node, expression, resolveInfo);
+            return mapDataFrameIndexColRowAssignment(node, expression, inference, resolveInfo);
         }
     }
     else if (node.type === type_1.RType.FunctionCall && node.named && node.arguments.length === 1 && node.arguments[0] !== r_function_call_1.EmptyArgument) {
         if (isDataFrameReplacement(node.functionName.content)) {
             const functionName = node.functionName.content;
-            const functionMapping = DataFrameReplacementFunctionMapper[functionName];
-            operations = functionMapping(node.arguments[0], expression, resolveInfo, parent);
+            const mapper = DataFrameReplacementFunctionMapper[functionName];
+            return mapper(node.arguments[0], expression, inference, resolveInfo, parent);
         }
         else {
-            operations = mapDataFrameUnknownAssignment(node.arguments[0], expression, resolveInfo);
+            return mapDataFrameUnknownAssignment(node.arguments[0], expression, inference);
         }
     }
-    if (operations !== undefined) {
-        return { type: 'expression', operations: operations };
-    }
 }
 function isDataFrameReplacement(functionName) {
     // a check with `functionName in DataFrameReplacementFunctionMapper` would return true for "toString"
@@ -60,9 +57,9 @@ function hasParentReplacement(node, dfg) {
     const parentVertex = node.info.parent ? dfg.getVertex(node.info.parent) : undefined;
     return (0, vertex_1.isFunctionCallVertex)(parentVertex) && parentVertex.origin.includes('builtin:replacement');
 }
-function mapDataFrameContentAssignment(access, expression, info) {
+function mapDataFrameContentAssignment(access, expression, inference) {
     const dataFrame = access.accessed;
-    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, info)) {
+    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, inference)) {
         return;
     }
     if ((0, arguments_1.isRNull)(expression)) {
@@ -81,9 +78,9 @@ function mapDataFrameContentAssignment(access, expression, info) {
             }];
     }
 }
-function mapDataFrameNamedColumnAssignment(access, expression, info) {
+function mapDataFrameNamedColumnAssignment(access, expression, 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);
@@ -104,10 +101,10 @@ function mapDataFrameNamedColumnAssignment(access, expression, info) {
             }];
     }
 }
-function mapDataFrameIndexColRowAssignment(access, expression, info) {
+function mapDataFrameIndexColRowAssignment(access, expression, inference, info) {
     const dataFrame = access.accessed;
     const args = access.access;
-    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, info) || args.every(arg => arg === r_function_call_1.EmptyArgument)) {
+    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, inference) || args.every(arg => arg === r_function_call_1.EmptyArgument)) {
         return;
     }
     const result = [];
@@ -159,8 +156,8 @@ function mapDataFrameIndexColRowAssignment(access, expression, info) {
     }
     return result;
 }
-function mapDataFrameColNamesAssignment(operand, expression, info, parent) {
-    if (!(0, arguments_1.isDataFrameArgument)(operand, info)) {
+function mapDataFrameColNamesAssignment(operand, expression, inference, info, parent) {
+    if (!(0, arguments_1.isDataFrameArgument)(operand, inference)) {
         return;
     }
     const argument = info.idMap !== undefined ? (0, make_argument_1.toUnnamedArgument)(expression, info.idMap) : r_function_call_1.EmptyArgument;
@@ -172,8 +169,8 @@ function mapDataFrameColNamesAssignment(operand, expression, info, parent) {
             ...(parent !== undefined ? { options: { partial: true } } : {})
         }];
 }
-function mapDataFrameRowNamesAssignment(operand, expression, info) {
-    if (!(0, arguments_1.isDataFrameArgument)(operand, info)) {
+function mapDataFrameRowNamesAssignment(operand, expression, inference) {
+    if (!(0, arguments_1.isDataFrameArgument)(operand, inference)) {
         return;
     }
     return [{
@@ -182,8 +179,8 @@ function mapDataFrameRowNamesAssignment(operand, expression, info) {
             type: semantics_1.ConstraintType.OperandModification
         }];
 }
-function mapDataFrameDimNamesAssignment(operand, expression, info) {
-    if (!(0, arguments_1.isDataFrameArgument)(operand, info)) {
+function mapDataFrameDimNamesAssignment(operand, expression, inference) {
+    if (!(0, arguments_1.isDataFrameArgument)(operand, inference)) {
         return;
     }
     return [{
@@ -192,8 +189,8 @@ function mapDataFrameDimNamesAssignment(operand, expression, info) {
             colnames: undefined
         }];
 }
-function mapDataFrameUnknownAssignment(operand, expression, info) {
-    if (!(0, arguments_1.isDataFrameArgument)(operand, info)) {
+function mapDataFrameUnknownAssignment(operand, expression, inference) {
+    if (!(0, arguments_1.isDataFrameArgument)(operand, inference)) {
         return;
     }
     return [{