@eagleoutice/flowr 2.9.14 → 2.10.2

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

@@ -1,9 +1,9 @@
 import type { ResolveInfo } from '../../../dataflow/eval/resolve/alias-tracking';
-import type { DataflowGraph } from '../../../dataflow/graph/graph';
+import { type DataflowGraph } from '../../../dataflow/graph/graph';
 import { RNode } from '../../../r-bridge/lang-4.x/ast/model/model';
-import type { RArgument } from '../../../r-bridge/lang-4.x/ast/model/nodes/r-argument';
-import { type RFunctionArgument, type RFunctionCall, EmptyArgument } from '../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
-import type { RSymbol } from '../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
+import { RArgument } from '../../../r-bridge/lang-4.x/ast/model/nodes/r-argument';
+import { type PotentiallyEmptyRArgument, type RFunctionCall, EmptyArgument } from '../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import { RSymbol } from '../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import type { ParentInformation } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { RNull } from '../../../r-bridge/lang-4.x/convert-values';
 import type { RParseRequest } from '../../../r-bridge/retriever';
@@ -44,14 +44,14 @@ export declare function filterValidNames(colnames: (string | undefined)[] | unde
  * @param info     - Argument resolve information
  * @returns The resolved value of the argument or `undefined`
  */
-export declare function getArgumentValue<T>(args: readonly RFunctionArgument<ParentInformation>[], argument: FunctionParameterLocation<T> | string, info: ResolveInfo): string | number | boolean | (string | number | boolean)[] | T | undefined;
+export declare function getArgumentValue<T>(args: readonly PotentiallyEmptyRArgument<ParentInformation>[], argument: FunctionParameterLocation<T> | string, info: ResolveInfo): string | number | boolean | (string | number | boolean)[] | T | undefined;
 /**
  * Gets all effective argument from a list of arguments by removing all arguments whose names should be excluded.
  * @param args     - The list of arguments to filter
  * @param excluded - The names of the arguments to exclude
  * @returns The filtered list of arguments
  */
-export declare function getEffectiveArgs(args: readonly RFunctionArgument<ParentInformation>[], excluded: string[]): readonly RFunctionArgument<ParentInformation>[];
+export declare function getEffectiveArgs(args: readonly PotentiallyEmptyRArgument<ParentInformation>[], excluded: readonly string[]): readonly PotentiallyEmptyRArgument<ParentInformation>[];
 /**
  * Gets an argument specified as {@link FunctionParameterLocation} from a list of arguments.
  * @param args     - The arguments to get the requested argument from
@@ -59,14 +59,14 @@ export declare function getEffectiveArgs(args: readonly RFunctionArgument<Parent
  * @param info     - Argument resolve information
  * @returns An argument matching the specified `argument` or `undefined`
  */
-export declare function getFunctionArgument(args: readonly RFunctionArgument<ParentInformation>[], argument: FunctionParameterLocation<unknown> | string, info: ResolveInfo): RFunctionArgument<ParentInformation> | undefined;
+export declare function getFunctionArgument(args: readonly PotentiallyEmptyRArgument<ParentInformation>[], argument: FunctionParameterLocation<unknown> | string, info: ResolveInfo): PotentiallyEmptyRArgument<ParentInformation> | undefined;
 /**
  * Get all function arguments of a function call node in the data flow graph.
  * @param node - The function call node to get the arguments for
  * @param dfg  - The data flow graph for retrieving the arguments
  * @returns The arguments of the function call in the data flow graph
  */
-export declare function getFunctionArguments(node: RFunctionCall<ParentInformation>, dfg: DataflowGraph): readonly RFunctionArgument<ParentInformation>[];
+export declare function getFunctionArguments(node: RFunctionCall<ParentInformation>, dfg: DataflowGraph): readonly PotentiallyEmptyRArgument<ParentInformation>[];
 /**
  * Gets all nested symbols in an expression that have no outgoing edges in the data flow graph.
  * @param expression - The expression to get the symbols from
@@ -81,7 +81,7 @@ export declare function getUnresolvedSymbolsInExpression(expression: RNode<Paren
  * @param info     - Argument resolve information
  * @returns Whether the arguments contain any critical argument
  */
-export declare function hasCriticalArgument(args: readonly RFunctionArgument<ParentInformation>[], critical: (FunctionParameterLocation<unknown> | string)[] | undefined, info: ResolveInfo): boolean;
+export declare function hasCriticalArgument(args: readonly PotentiallyEmptyRArgument<ParentInformation>[], critical: (FunctionParameterLocation<unknown> | string)[] | undefined, info: ResolveInfo): boolean;
 /**
  * Checks if a given argument has an inferred data frame shape and therefore represents a data frame
  * @param arg       - The argument to check
@@ -89,20 +89,14 @@ export declare function hasCriticalArgument(args: readonly RFunctionArgument<Par
  * @returns Whether the argument represents a data frame
  */
 export declare function isDataFrameArgument(arg: RNode<ParentInformation> | undefined, inference: DataFrameShapeInferenceVisitor): arg is RNode<ParentInformation>;
-export declare function isDataFrameArgument(arg: RFunctionArgument<ParentInformation> | undefined, inference: DataFrameShapeInferenceVisitor): arg is RArgument<ParentInformation> & {
+export declare function isDataFrameArgument(arg: PotentiallyEmptyRArgument<ParentInformation> | undefined, inference: DataFrameShapeInferenceVisitor): arg is RArgument<ParentInformation> & {
     value: RNode<ParentInformation>;
 };
-/**
- * Checks whether a function argument is a names argument.
- */
-export declare function isNamedArgument(arg: RFunctionArgument<ParentInformation> | undefined): arg is RArgument<ParentInformation> & {
-    name: RSymbol<ParentInformation>;
-};
 /**
  * Checks whether a node is `NULL` in R (represents a `NULL` symbol).
  */
 export declare function isRNull(node: RNode<ParentInformation> | undefined): node is RSymbol<ParentInformation, typeof RNull>;
-export declare function isRNull(node: RFunctionArgument<ParentInformation> | undefined): node is RArgument<ParentInformation> & {
+export declare function isRNull(node: PotentiallyEmptyRArgument<ParentInformation> | undefined): node is RArgument<ParentInformation> & {
     value: RSymbol<ParentInformation, typeof RNull>;
 };
 /**

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;