@eagleoutice/flowr 2.7.0 → 2.7.3

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

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

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

@@ -6,7 +6,8 @@ import { type RFunctionArgument, type RFunctionCall, EmptyArgument } from '../..
 import type { RSymbol } from '../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import type { ParentInformation } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { RNull } from '../../../r-bridge/lang-4.x/convert-values';
-import type { AbstractInterpretationInfo } from '../absint-info';
+import type { RParseRequest } from '../../../r-bridge/retriever';
+import type { DataFrameShapeInferenceVisitor } from '../shape-inference';
 /**
  * The location of a function parameter for mapping function call arguments to function parameters.
  * - `pos` contains the position of the function parameter (use `-1` for non-existent or non-positional arguments)
@@ -31,9 +32,10 @@ export declare function escapeRegExp(text: string, allowTokens?: boolean): strin
  * @param checkNames   - Whether to map all invalid column names to top (`undefined`)
  * @param noDupNames   - Whether to map all duplicate column names to top (`undefined`)
  * @param noEmptyNames - Whether to map all empty column names to top (`undefined`)
+ * @param collapseDups - Whether duplicate columns should be collapsed to single occurrences afterward (excluding `undefined` values)
  * @returns The filtered column names
  */
-export declare function filterValidNames(colnames: (string | undefined)[] | undefined, checkNames?: boolean, noDupNames?: boolean, noEmptyNames?: boolean): (string | undefined)[] | undefined;
+export declare function filterValidNames(colnames: (string | undefined)[] | undefined, checkNames?: boolean, noDupNames?: boolean, noEmptyNames?: boolean, collapseDups?: boolean): (string | undefined)[] | undefined;
 /**
  * Gets the value of an argument that specified as {@link FunctionParameterLocation}.
  * @param args     - The arguments to get the requested argument from
@@ -80,14 +82,14 @@ export declare function getUnresolvedSymbolsInExpression(expression: RNode<Paren
  */
 export declare function hasCriticalArgument(args: readonly RFunctionArgument<ParentInformation>[], critical: (FunctionParameterLocation<unknown> | string)[] | undefined, info: ResolveInfo): boolean;
 /**
- * Checks if a given argument has any data frame shape information and therefore may represent a data frame.
- * @param arg  - The argument to check
- * @param info - Argument resolve information
- * @returns Whether the argument has any data frame shape information and may represent a data frame
+ * Checks if a given argument has an inferred data frame shape and therefore represents a data frame
+ * @param arg       - The argument to check
+ * @param inference - The data frame shape inference visitor to use
+ * @returns Whether the argument represents a data frame
  */
-export declare function isDataFrameArgument(arg: RNode<ParentInformation> | undefined, info: ResolveInfo): arg is RNode<ParentInformation & Required<AbstractInterpretationInfo>>;
-export declare function isDataFrameArgument(arg: RFunctionArgument<ParentInformation> | undefined, info: ResolveInfo): arg is RArgument<ParentInformation & Required<AbstractInterpretationInfo>> & {
-    value: RNode<ParentInformation & Required<AbstractInterpretationInfo>>;
+export declare function isDataFrameArgument(arg: RNode<ParentInformation> | undefined, inference: DataFrameShapeInferenceVisitor): arg is RNode<ParentInformation>;
+export declare function isDataFrameArgument(arg: RFunctionArgument<ParentInformation> | undefined, inference: DataFrameShapeInferenceVisitor): arg is RArgument<ParentInformation> & {
+    value: RNode<ParentInformation>;
 };
 /**
  * Checks whether a function argument is a names argument.
@@ -106,3 +108,7 @@ export declare function isRNull(node: RFunctionArgument<ParentInformation> | und
  * Checks whether a string is a valid columns name according to the flag `check.names` in R.
  */
 export declare function isValidColName(colname: string | undefined): boolean;
+/**
+ * Parses a text of file parse request using the provided parser function.
+ */
+export declare function parseRequestContent(request: RParseRequest, parser: (line: Buffer | string, lineNumber: number) => void, maxLines?: number): boolean;

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

@@ -12,16 +12,20 @@ exports.isDataFrameArgument = isDataFrameArgument;
 exports.isNamedArgument = isNamedArgument;
 exports.isRNull = isRNull;
 exports.isValidColName = isValidColName;
+exports.parseRequestContent = parseRequestContent;
 const vertex_1 = require("../../../dataflow/graph/vertex");
 const make_argument_1 = require("../../../dataflow/internal/process/functions/call/argument/make-argument");
 const r_function_call_1 = require("../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const visitor_1 = require("../../../r-bridge/lang-4.x/ast/model/processing/visitor");
 const type_1 = require("../../../r-bridge/lang-4.x/ast/model/type");
 const convert_values_1 = require("../../../r-bridge/lang-4.x/convert-values");
+const assert_1 = require("../../../util/assert");
+const files_1 = require("../../../util/files");
 const resolve_args_1 = require("../resolve-args");
-const shape_inference_1 = require("../shape-inference");
 /** Regular expression representing valid columns names, e.g. for `data.frame` */
 const ColNamesRegex = /^[A-Za-z.][A-Za-z0-9_.]*$/;
+/** Regular expression representing line terminations (LF, CRLF, CR) */
+const LineTerminationRegex = /\r\n|\r|\n/;
 /**
  * Escapes a regular expression given as string by escaping all special regular expression characters.
  * @param text        - The text to escape
@@ -42,9 +46,10 @@ function escapeRegExp(text, allowTokens = false) {
  * @param checkNames   - Whether to map all invalid column names to top (`undefined`)
  * @param noDupNames   - Whether to map all duplicate column names to top (`undefined`)
  * @param noEmptyNames - Whether to map all empty column names to top (`undefined`)
+ * @param collapseDups - Whether duplicate columns should be collapsed to single occurrences afterward (excluding `undefined` values)
  * @returns The filtered column names
  */
-function filterValidNames(colnames, checkNames, noDupNames, noEmptyNames) {
+function filterValidNames(colnames, checkNames, noDupNames, noEmptyNames, collapseDups = false) {
     if (checkNames) { // map all invalid column names to top
         colnames = colnames?.map(entry => isValidColName(entry) ? entry : undefined);
     }
@@ -54,6 +59,9 @@ function filterValidNames(colnames, checkNames, noDupNames, noEmptyNames) {
     if (noEmptyNames) { // map all empty column names to top
         colnames = colnames?.map(entry => entry?.length === 0 ? undefined : entry);
     }
+    if (collapseDups) {
+        colnames = colnames?.filter((value, index, array) => value === undefined || array.indexOf(value) === index);
+    }
     return colnames;
 }
 /**
@@ -157,8 +165,8 @@ function hasCriticalArgument(args, critical, info) {
     }
     return false;
 }
-function isDataFrameArgument(arg, info) {
-    return arg !== r_function_call_1.EmptyArgument && (0, shape_inference_1.resolveIdToDataFrameShape)(arg, info.graph) !== undefined;
+function isDataFrameArgument(arg, inference) {
+    return arg !== r_function_call_1.EmptyArgument && inference.getAbstractValue(arg) !== undefined;
 }
 /**
  * Checks whether a function argument is a names argument.
@@ -178,4 +186,19 @@ function isRNull(node) {
 function isValidColName(colname) {
     return colname !== undefined && ColNamesRegex.test(colname);
 }
+/**
+ * Parses a text of file parse request using the provided parser function.
+ */
+function parseRequestContent(request, parser, maxLines) {
+    const requestType = request.request;
+    switch (requestType) {
+        case 'text':
+            (0, resolve_args_1.unescapeSpecialChars)(request.content).split(LineTerminationRegex).forEach(parser);
+            return true;
+        case 'file':
+            return (0, files_1.readLineByLineSync)(request.content, parser, maxLines);
+        default:
+            (0, assert_1.assertUnreachable)(requestType);
+    }
+}
 //# sourceMappingURL=arguments.js.map

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

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