@eagleoutice/flowr 2.7.0 → 2.7.3

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

@@ -8,10 +8,8 @@ const r_function_call_1 = require("../../../r-bridge/lang-4.x/ast/model/nodes/r-
 const type_1 = require("../../../r-bridge/lang-4.x/ast/model/type");
 const retriever_1 = require("../../../r-bridge/retriever");
 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 +520,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 +545,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 +563,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 +589,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 +599,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 +612,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 +637,7 @@ function mapDataFrameRead(args, params, info, ctx) {
             }
         }
     };
-    const allLines = parseRequestContent(request, parseLine, ctx.config.abstractInterpretation.dataFrame.readLoadedData.maxReadLines);
+    const allLines = (0, arguments_1.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 +653,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 +667,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 +695,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 +709,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 +736,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 +766,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 +829,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 +857,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 +909,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 +931,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 +959,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 +988,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 +1015,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 +1032,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 +1067,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 +1081,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,23 +1098,24 @@ 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) {
         const fileName = (0, resolve_args_1.resolveIdToArgValue)(fileNameArg, info);
         if (typeof fileName === 'string') {
+            const text = (0, resolve_args_1.unescapeSpecialChars)(fileName);
             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
                 request = { request: 'file', content: sources[0] };
             }
-            else if (params.text === undefined && (0, resolve_args_1.unescapeSpecialChars)(fileName).includes('\n')) {
+            else if (params.text === undefined && text.includes('\n')) {
                 // create request from string if file name argument contains newline
-                request = (0, retriever_1.requestFromInput)((0, resolve_args_1.unescapeSpecialChars)(fileName));
+                request = (0, retriever_1.requestFromInput)(text);
             }
         }
     }
@@ -1131,28 +1126,16 @@ 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) {
-    const requestType = request.request;
-    switch (requestType) {
-        case 'text':
-            request.content.split('\n').forEach(parser);
-            return true;
-        case 'file':
-            return (0, files_1.readLineByLineSync)(request.content, parser, maxLines);
-        default:
-            (0, assert_1.assertUnreachable)(requestType);
-    }
-}
 /**
  * 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 = (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, true);
-    comment = (0, arguments_1.escapeRegExp)(comment, true);
+    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 LineCommentRegex = new RegExp(`[${comment}].*`);
     const CsvEntryRegex = new RegExp(`(?<=^|[${sep}])(?:[${quote}]((?:[^${quote}]|[${quote}]{2})*)[${quote}]|([^${sep}]${quantifier}))`, 'g');
@@ -1177,6 +1160,11 @@ function getSelectedColumns(args, info) {
                 selectedCols = joinColumns(selectedCols, result.selectedCols);
                 unselectedCols = joinColumns(unselectedCols, result.unselectedCols);
             }
+            else if (arg.value?.type === type_1.RType.UnaryOp && arg.value.operator === '+' && info.idMap !== undefined) {
+                const result = getSelectedColumns([(0, make_argument_1.toUnnamedArgument)(arg.value.operand, info.idMap)], info);
+                selectedCols = joinColumns(selectedCols, result.selectedCols);
+                unselectedCols = joinColumns(unselectedCols, result.unselectedCols);
+            }
             else if (arg.value?.type === type_1.RType.UnaryOp && arg.value.operator === '-' && info.idMap !== undefined) {
                 const result = getSelectedColumns([(0, make_argument_1.toUnnamedArgument)(arg.value.operand, info.idMap)], info);
                 selectedCols = joinColumns(selectedCols, result.unselectedCols);

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

@@ -1,13 +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 { ReadOnlyFlowrAnalyzerContext } from '../../../project/context/flowr-analyzer-context';
+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
- * @param ctx - The read-only Flowr analysis context
- * @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, ctx: ReadOnlyFlowrAnalyzerContext): 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,40 +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
- * @param ctx - The read-only Flowr analysis context
- * @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, ctx) {
+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, ctx };
-    let operations;
     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"
@@ -61,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)) {
@@ -82,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);
@@ -105,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 = [];
@@ -160,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;
@@ -173,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 [{
@@ -183,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 [{
@@ -193,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 [{

package/abstract-interpretation/data-frame/resolve-args.d.ts

@@ -35,7 +35,7 @@ export declare function unescapeQuotes(argument: undefined): undefined;
 export declare function unescapeQuotes(argument: string): string;
 export declare function unescapeQuotes(argument: string | undefined): string | undefined;
 /**
- * Unescapes escape sequences like `\n`, `\t`, `\'`, `\"`, `\\` back into actual newlines, tabs, quotes, and backslashes
+ * Unescapes escape sequences like `\r`, `\n`, `\t`, `\'`, `\"`, `\\` back into actual newlines, tabs, quotes, and backslashes
  */
 export declare function unescapeSpecialChars(argument: undefined): undefined;
 export declare function unescapeSpecialChars(argument: string): string;

package/abstract-interpretation/data-frame/resolve-args.js

@@ -113,6 +113,6 @@ function unescapeSpecialChars(argument) {
     if (argument === undefined) {
         return undefined;
     }
-    return unescapeQuotes(argument).replaceAll('\\n', '\n').replaceAll('\\t', '\t').replaceAll('\\\\', '\\');
+    return unescapeQuotes(argument).replaceAll('\\r', '\r').replaceAll('\\n', '\n').replaceAll('\\t', '\t').replaceAll('\\\\', '\\');
 }
 //# sourceMappingURL=resolve-args.js.map

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

@@ -111,10 +111,9 @@ function applyAccessRowsSemantics(value, { rows }) {
 }
 function applyAssignColsSemantics(value, { columns }) {
     if (columns?.every(col => typeof col === 'string')) {
-        const cols = columns.length;
         return new dataframe_domain_1.DataFrameDomain({
             colnames: value.colnames.union(setRange(columns)),
-            cols: value.cols.add([0, cols]).max([cols, cols]),
+            cols: value.cols.add([0, columns.length]).max([columns.length, columns.length]),
             rows: value.rows
         });
     }
@@ -155,7 +154,7 @@ function applySetColNamesSemantics(value, { colnames }, options) {
     }
     const allColNames = colnames?.every(assert_1.isNotUndefined) && value.cols.value !== lattice_1.Bottom && colnames.length >= value.cols.value[1];
     return new dataframe_domain_1.DataFrameDomain({
-        colnames: allColNames ? value.colnames.create(setRange(colnames)) : value.colnames.widenDown().union(setRange(colnames)).widenUp(),
+        colnames: allColNames ? value.colnames.create(setRange(colnames)) : value.colnames.create(setRange(colnames)).widenUp(),
         cols: value.cols,
         rows: value.rows
     });
@@ -347,13 +346,13 @@ function applyJoinSemantics(value, { other, by }, options) {
     let rows;
     switch (joinType) {
         case 'inner':
-            rows = value.rows.min(other.rows).widenDown();
+            rows = value.rows.max(other.rows).widenDown();
             break;
         case 'left':
-            rows = value.rows;
+            rows = value.rows.max(other.rows.isValue() ? [0, other.rows.value[1]] : lattice_1.Bottom);
             break;
         case 'right':
-            rows = other.rows;
+            rows = other.rows.max(value.rows.isValue() ? [0, value.rows.value[1]] : lattice_1.Bottom);
             break;
         case 'full':
             rows = mergeInterval(value.rows, other.rows);