@eagleoutice/flowr 2.10.1 → 2.10.3

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

@@ -9,15 +9,16 @@ exports.getFunctionArguments = getFunctionArguments;
 exports.getUnresolvedSymbolsInExpression = getUnresolvedSymbolsInExpression;
 exports.hasCriticalArgument = hasCriticalArgument;
 exports.isDataFrameArgument = isDataFrameArgument;
-exports.isNamedArgument = isNamedArgument;
 exports.isRNull = isRNull;
 exports.isValidColName = isValidColName;
 exports.parseRequestContent = parseRequestContent;
+const graph_1 = require("../../../dataflow/graph/graph");
 const vertex_1 = require("../../../dataflow/graph/vertex");
 const make_argument_1 = require("../../../dataflow/internal/process/functions/call/argument/make-argument");
 const model_1 = require("../../../r-bridge/lang-4.x/ast/model/model");
+const r_argument_1 = require("../../../r-bridge/lang-4.x/ast/model/nodes/r-argument");
 const r_function_call_1 = require("../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
-const type_1 = require("../../../r-bridge/lang-4.x/ast/model/type");
+const r_symbol_1 = require("../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol");
 const convert_values_1 = require("../../../r-bridge/lang-4.x/convert-values");
 const assert_1 = require("../../../util/assert");
 const files_1 = require("../../../util/files");
@@ -84,7 +85,7 @@ function getArgumentValue(args, argument, info) {
  * @returns The filtered list of arguments
  */
 function getEffectiveArgs(args, excluded) {
-    return args.filter(arg => arg === r_function_call_1.EmptyArgument || arg.name === undefined || !excluded.includes((0, resolve_args_1.unquoteArgument)(arg.name.content)));
+    return args.filter(arg => r_argument_1.RArgument.isEmpty(arg) || !r_argument_1.RArgument.isNamed(arg) || !excluded.includes((0, resolve_args_1.unquoteArgument)(arg.name.content)));
 }
 /**
  * Gets an argument specified as {@link FunctionParameterLocation} from a list of arguments.
@@ -114,11 +115,11 @@ function getFunctionArgument(args, argument, info) {
  */
 function getFunctionArguments(node, dfg) {
     const vertex = dfg.getVertex(node.info.id);
-    if (vertex?.tag === vertex_1.VertexType.FunctionCall && dfg.idMap !== undefined) {
+    if ((0, vertex_1.isFunctionCallVertex)(vertex) && dfg.idMap !== undefined) {
         const idMap = dfg.idMap;
         return vertex.args
-            .map(arg => arg === r_function_call_1.EmptyArgument ? arg : idMap.get(arg.nodeId))
-            .map(arg => arg === r_function_call_1.EmptyArgument || arg?.type === type_1.RType.Argument ? arg : (0, make_argument_1.toUnnamedArgument)(arg, idMap));
+            .map(arg => graph_1.FunctionArgument.isEmpty(arg) ? arg : idMap.get(arg.nodeId))
+            .map(arg => r_argument_1.RArgument.isEmpty(arg) || r_argument_1.RArgument.is(arg) ? arg : (0, make_argument_1.toUnnamedArgument)(arg, idMap));
     }
     return node.arguments;
 }
@@ -134,10 +135,12 @@ function getUnresolvedSymbolsInExpression(expression, dfg) {
     }
     const unresolvedSymbols = [];
     model_1.RNode.visitAst(expression, node => {
-        if (node.type === type_1.RType.Symbol) {
+        if (r_symbol_1.RSymbol.is(node)) {
             const vertex = dfg.get(node.info.id);
-            if ((0, vertex_1.isUseVertex)(vertex?.[0]) && vertex[1].size === 0) {
-                unresolvedSymbols.push(identifier_1.Identifier.mapName(node.content, resolve_args_1.unquoteArgument));
+            const symbolName = identifier_1.Identifier.mapName(node.content, resolve_args_1.unquoteArgument);
+            // ignore symbols named ".", as they are used as argument placeholder in magrittr pipe operations
+            if ((0, vertex_1.isUseVertex)(vertex?.[0]) && vertex[1].size === 0 && symbolName !== '.') {
+                unresolvedSymbols.push(symbolName);
             }
         }
     });
@@ -169,17 +172,14 @@ function hasCriticalArgument(args, critical, info) {
 function isDataFrameArgument(arg, inference) {
     return arg !== r_function_call_1.EmptyArgument && inference.getAbstractValue(arg) !== undefined;
 }
-/**
- * Checks whether a function argument is a names argument.
- */
-function isNamedArgument(arg) {
-    return arg !== r_function_call_1.EmptyArgument && arg?.name !== undefined;
-}
 function isRNull(node) {
-    if (node === r_function_call_1.EmptyArgument || node?.type === type_1.RType.Argument) {
-        return node !== r_function_call_1.EmptyArgument && isRNull(node.value);
+    if (r_argument_1.RArgument.isEmpty(node)) {
+        return false;
+    }
+    else if (r_argument_1.RArgument.is(node)) {
+        return isRNull(node.value);
     }
-    return node?.type === type_1.RType.Symbol && node.content === convert_values_1.RNull;
+    return r_symbol_1.RSymbol.is(node) && node.content === convert_values_1.RNull;
 }
 /**
  * Checks whether a string is a valid columns name according to the flag `check.names` in R.

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

@@ -2,7 +2,7 @@ import { type ResolveInfo } from '../../../dataflow/eval/resolve/alias-tracking'
 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 RFunctionArgument } from '../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import { type PotentiallyEmptyRArgument } 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 { DataFrameOperations, DataFrameShapeInferenceVisitor } from '../shape-inference';
 import { type FunctionParameterLocation } from './arguments';
@@ -23,61 +23,73 @@ declare const DataFrameFunctionMapper: {
         readonly mapper: typeof mapDataFrameCreate;
         readonly library: "base";
         readonly returnType: DataFrameType.DataFrame;
+        readonly alwaysDataFrame: true;
     };
     readonly 'as.data.frame': {
         readonly mapper: typeof mapDataFrameConvert;
         readonly library: "base";
         readonly returnType: DataFrameType.DataFrame;
+        readonly alwaysDataFrame: true;
     };
     readonly 'read.table': {
         readonly mapper: typeof mapDataFrameRead;
         readonly library: "utils";
         readonly returnType: DataFrameType.DataFrame;
+        readonly alwaysDataFrame: true;
     };
     readonly 'read.csv': {
         readonly mapper: typeof mapDataFrameRead;
         readonly library: "utils";
         readonly returnType: DataFrameType.DataFrame;
+        readonly alwaysDataFrame: true;
     };
     readonly 'read.csv2': {
         readonly mapper: typeof mapDataFrameRead;
         readonly library: "utils";
         readonly returnType: DataFrameType.DataFrame;
+        readonly alwaysDataFrame: true;
     };
     readonly 'read.delim': {
         readonly mapper: typeof mapDataFrameRead;
         readonly library: "utils";
         readonly returnType: DataFrameType.DataFrame;
+        readonly alwaysDataFrame: true;
     };
     readonly 'read.delim2': {
         readonly mapper: typeof mapDataFrameRead;
         readonly library: "utils";
         readonly returnType: DataFrameType.DataFrame;
+        readonly alwaysDataFrame: true;
     };
     readonly read_table: {
         readonly mapper: typeof mapDataFrameRead;
         readonly library: "readr";
         readonly returnType: DataFrameType.Tibble;
+        readonly alwaysDataFrame: true;
     };
     readonly read_csv: {
         readonly mapper: typeof mapDataFrameRead;
         readonly library: "readr";
         readonly returnType: DataFrameType.Tibble;
+        readonly alwaysDataFrame: true;
     };
     readonly read_csv2: {
         readonly mapper: typeof mapDataFrameRead;
         readonly library: "readr";
         readonly returnType: DataFrameType.Tibble;
+        readonly alwaysDataFrame: true;
     };
     readonly read_tsv: {
         readonly mapper: typeof mapDataFrameRead;
         readonly library: "readr";
         readonly returnType: DataFrameType.Tibble;
+        readonly alwaysDataFrame: true;
     };
     readonly read_delim: {
         readonly mapper: typeof mapDataFrameRead;
         readonly library: "readr";
         readonly returnType: DataFrameType.Tibble;
+        readonly alwaysDataFrame: true;
     };
     readonly cbind: {
         readonly mapper: typeof mapDataFrameColBind;
@@ -108,71 +120,85 @@ declare const DataFrameFunctionMapper: {
         readonly mapper: typeof mapDataFrameFilter;
         readonly library: "dplyr";
         readonly returnType: DataFrameType.DataFrame;
+        readonly alwaysDataFrame: true;
     };
     readonly select: {
         readonly mapper: typeof mapDataFrameSelect;
         readonly library: "dplyr";
         readonly returnType: DataFrameType.DataFrame;
+        readonly alwaysDataFrame: true;
     };
     readonly mutate: {
         readonly mapper: typeof mapDataFrameMutate;
         readonly library: "dplyr";
         readonly returnType: DataFrameType.DataFrame;
+        readonly alwaysDataFrame: true;
     };
     readonly transform: {
         readonly mapper: typeof mapDataFrameMutate;
         readonly library: "base";
         readonly returnType: DataFrameType.DataFrame;
+        readonly alwaysDataFrame: true;
     };
     readonly group_by: {
         readonly mapper: typeof mapDataFrameGroupBy;
         readonly library: "dplyr";
         readonly returnType: DataFrameType.Tibble;
+        readonly alwaysDataFrame: true;
     };
     readonly summarise: {
         readonly mapper: typeof mapDataFrameSummarize;
         readonly library: "dplyr";
         readonly returnType: DataFrameType.DataFrame;
+        readonly alwaysDataFrame: true;
     };
     readonly summarize: {
         readonly mapper: typeof mapDataFrameSummarize;
         readonly library: "dplyr";
         readonly returnType: DataFrameType.DataFrame;
+        readonly alwaysDataFrame: true;
     };
     readonly inner_join: {
         readonly mapper: typeof mapDataFrameJoin;
         readonly library: "dplyr";
         readonly returnType: DataFrameType.DataFrame;
+        readonly alwaysDataFrame: true;
     };
     readonly left_join: {
         readonly mapper: typeof mapDataFrameJoin;
         readonly library: "dplyr";
         readonly returnType: DataFrameType.DataFrame;
+        readonly alwaysDataFrame: true;
     };
     readonly right_join: {
         readonly mapper: typeof mapDataFrameJoin;
         readonly library: "dplyr";
         readonly returnType: DataFrameType.DataFrame;
+        readonly alwaysDataFrame: true;
     };
     readonly full_join: {
         readonly mapper: typeof mapDataFrameJoin;
         readonly library: "dplyr";
         readonly returnType: DataFrameType.DataFrame;
+        readonly alwaysDataFrame: true;
     };
     readonly merge: {
         readonly mapper: typeof mapDataFrameJoin;
         readonly library: "base";
         readonly returnType: DataFrameType.DataFrame;
+        readonly alwaysDataFrame: true;
     };
     readonly relocate: {
         readonly mapper: typeof mapDataFrameIdentity;
         readonly library: "dplyr";
         readonly returnType: DataFrameType.DataFrame;
+        readonly alwaysDataFrame: true;
     };
     readonly arrange: {
         readonly mapper: typeof mapDataFrameIdentity;
         readonly library: "dplyr";
         readonly returnType: DataFrameType.DataFrame;
+        readonly alwaysDataFrame: true;
     };
 };
 /** All currently supported data frame functions */
@@ -186,15 +212,15 @@ type DataFrameFunction = keyof typeof DataFrameFunctionMapper;
  * @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>, inference: DataFrameShapeInferenceVisitor, dfg: DataflowGraph, ctx: ReadOnlyFlowrAnalyzerContext): DataFrameOperations;
-declare function mapDataFrameCreate(args: readonly RFunctionArgument<ParentInformation>[], params: {
+declare function mapDataFrameCreate(args: readonly PotentiallyEmptyRArgument<ParentInformation>[], params: {
     checkNames: FunctionParameterLocation<boolean>;
     noDupNames: FunctionParameterLocation<boolean>;
     special: string[];
 }, inference: DataFrameShapeInferenceVisitor, info: ResolveInfo): DataFrameOperations;
-declare function mapDataFrameConvert(args: readonly RFunctionArgument<ParentInformation>[], params: {
+declare function mapDataFrameConvert(args: readonly PotentiallyEmptyRArgument<ParentInformation>[], params: {
     dataFrame: FunctionParameterLocation;
 }, inference: DataFrameShapeInferenceVisitor, info: ResolveInfo): DataFrameOperations;
-declare function mapDataFrameRead(args: readonly RFunctionArgument<ParentInformation>[], params: {
+declare function mapDataFrameRead(args: readonly PotentiallyEmptyRArgument<ParentInformation>[], params: {
     fileName: FunctionParameterLocation;
     text?: FunctionParameterLocation;
     header: FunctionParameterLocation<boolean>;
@@ -206,46 +232,46 @@ declare function mapDataFrameRead(args: readonly RFunctionArgument<ParentInforma
     noDupNames: FunctionParameterLocation<boolean>;
     noEmptyNames?: boolean;
 }, inference: DataFrameShapeInferenceVisitor, info: ResolveInfo): DataFrameOperations;
-declare function mapDataFrameColBind(args: readonly RFunctionArgument<ParentInformation>[], params: {
+declare function mapDataFrameColBind(args: readonly PotentiallyEmptyRArgument<ParentInformation>[], params: {
     special: string[];
 }, inference: DataFrameShapeInferenceVisitor, info: ResolveInfo): DataFrameOperations;
-declare function mapDataFrameRowBind(args: readonly RFunctionArgument<ParentInformation>[], params: {
+declare function mapDataFrameRowBind(args: readonly PotentiallyEmptyRArgument<ParentInformation>[], params: {
     special: string[];
 }, inference: DataFrameShapeInferenceVisitor, info: ResolveInfo): DataFrameOperations;
-declare function mapDataFrameHeadTail(args: readonly RFunctionArgument<ParentInformation>[], params: {
+declare function mapDataFrameHeadTail(args: readonly PotentiallyEmptyRArgument<ParentInformation>[], params: {
     dataFrame: FunctionParameterLocation;
     amount: FunctionParameterLocation<number>;
 }, inference: DataFrameShapeInferenceVisitor, info: ResolveInfo): DataFrameOperations;
-declare function mapDataFrameSubset(args: readonly RFunctionArgument<ParentInformation>[], params: {
+declare function mapDataFrameSubset(args: readonly PotentiallyEmptyRArgument<ParentInformation>[], params: {
     dataFrame: FunctionParameterLocation;
     subset: FunctionParameterLocation;
     select: FunctionParameterLocation;
     drop: FunctionParameterLocation<boolean>;
 }, inference: DataFrameShapeInferenceVisitor, info: ResolveInfo): DataFrameOperations;
-declare function mapDataFrameFilter(args: readonly RFunctionArgument<ParentInformation>[], params: {
+declare function mapDataFrameFilter(args: readonly PotentiallyEmptyRArgument<ParentInformation>[], params: {
     dataFrame: FunctionParameterLocation;
     special: string[];
 }, inference: DataFrameShapeInferenceVisitor, info: ResolveInfo): DataFrameOperations;
-declare function mapDataFrameSelect(args: readonly RFunctionArgument<ParentInformation>[], params: {
+declare function mapDataFrameSelect(args: readonly PotentiallyEmptyRArgument<ParentInformation>[], params: {
     dataFrame: FunctionParameterLocation;
     special: string[];
 }, inference: DataFrameShapeInferenceVisitor, info: ResolveInfo): DataFrameOperations;
-declare function mapDataFrameMutate(args: readonly RFunctionArgument<ParentInformation>[], params: {
+declare function mapDataFrameMutate(args: readonly PotentiallyEmptyRArgument<ParentInformation>[], params: {
     dataFrame: FunctionParameterLocation;
     special: string[];
     checkNames?: boolean;
     noDupNames?: boolean;
 }, inference: DataFrameShapeInferenceVisitor, info: ResolveInfo): DataFrameOperations;
-declare function mapDataFrameGroupBy(args: readonly RFunctionArgument<ParentInformation>[], params: {
+declare function mapDataFrameGroupBy(args: readonly PotentiallyEmptyRArgument<ParentInformation>[], params: {
     dataFrame: FunctionParameterLocation;
     by: FunctionParameterLocation;
     special: string[];
 }, inference: DataFrameShapeInferenceVisitor, info: ResolveInfo): DataFrameOperations;
-declare function mapDataFrameSummarize(args: readonly RFunctionArgument<ParentInformation>[], params: {
+declare function mapDataFrameSummarize(args: readonly PotentiallyEmptyRArgument<ParentInformation>[], params: {
     dataFrame: FunctionParameterLocation;
     special: string[];
 }, inference: DataFrameShapeInferenceVisitor, info: ResolveInfo): DataFrameOperations;
-declare function mapDataFrameJoin(args: readonly RFunctionArgument<ParentInformation>[], params: {
+declare function mapDataFrameJoin(args: readonly PotentiallyEmptyRArgument<ParentInformation>[], params: {
     dataFrame: FunctionParameterLocation;
     otherDataFrame: FunctionParameterLocation;
     by: FunctionParameterLocation;
@@ -253,7 +279,7 @@ declare function mapDataFrameJoin(args: readonly RFunctionArgument<ParentInforma
     joinLeft: FunctionParameterLocation<boolean>;
     joinRight: FunctionParameterLocation<boolean>;
 }, inference: DataFrameShapeInferenceVisitor, info: ResolveInfo): DataFrameOperations;
-declare function mapDataFrameIdentity(args: readonly RFunctionArgument<ParentInformation>[], params: {
+declare function mapDataFrameIdentity(args: readonly PotentiallyEmptyRArgument<ParentInformation>[], params: {
     dataFrame: FunctionParameterLocation;
     special: string[];
     disallowNamedArgs?: boolean;

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

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

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

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

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

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