@eagleoutice/flowr 2.6.1 → 2.6.3

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

@@ -16,7 +16,6 @@ const SpecialAccessArgumentsMapper = {
 };
 /**
  * Maps a concrete data frame access to abstract data frame operations.
- *
  * @param node - The R node of the access
  * @param dfg  - The data flow graph for resolving the arguments
  * @returns Data frame expression info containing the mapped abstract data frame operations, or `undefined` if the node does not represent a data frame access

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

@@ -2,8 +2,7 @@ import type { ResolveInfo } from '../../../dataflow/eval/resolve/alias-tracking'
 import type { DataflowGraph } from '../../../dataflow/graph/graph';
 import type { 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, RFunctionCall } from '../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
-import { EmptyArgument } from '../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+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 type { ParentInformation } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { RNull } from '../../../r-bridge/lang-4.x/convert-values';
@@ -21,7 +20,6 @@ export interface FunctionParameterLocation<T = never> {
 }
 /**
  * Escapes a regular expression given as string by escaping all special regular expression characters.
- *
  * @param text        - The text to escape
  * @param allowTokens - Whether to allow and keep unescaped tokens like `\s`, `\t`, or `\n`
  * @returns The escaped text
@@ -29,7 +27,6 @@ export interface FunctionParameterLocation<T = never> {
 export declare function escapeRegExp(text: string, allowTokens?: boolean): string;
 /**
  * Maps all invalid, duplicate, or empty column names to top depending on the provided arguments.
- *
  * @param colnames     - The columns names to filter
  * @param checkNames   - Whether to map all invalid column names to top (`undefined`)
  * @param noDupNames   - Whether to map all duplicate column names to top (`undefined`)
@@ -39,7 +36,6 @@ export declare function escapeRegExp(text: string, allowTokens?: boolean): strin
 export declare function filterValidNames(colnames: (string | undefined)[] | undefined, checkNames?: boolean, noDupNames?: boolean, noEmptyNames?: 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
  * @param argument - The specification of the argument to get the value for
  * @param info     - Argument resolve information
@@ -48,7 +44,6 @@ export declare function filterValidNames(colnames: (string | undefined)[] | unde
 export declare function getArgumentValue<T>(args: readonly RFunctionArgument<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
@@ -56,7 +51,6 @@ export declare function getArgumentValue<T>(args: readonly RFunctionArgument<Par
 export declare function getEffectiveArgs(args: readonly RFunctionArgument<ParentInformation>[], excluded: string[]): readonly RFunctionArgument<ParentInformation>[];
 /**
  * Gets an argument specified as {@link FunctionParameterLocation} from a list of arguments.
- *
  * @param args     - The arguments to get the requested argument from
  * @param argument - The specification of the argument to get
  * @param info     - Argument resolve information
@@ -65,7 +59,6 @@ export declare function getEffectiveArgs(args: readonly RFunctionArgument<Parent
 export declare function getFunctionArgument(args: readonly RFunctionArgument<ParentInformation>[], argument: FunctionParameterLocation<unknown> | string, info: ResolveInfo): RFunctionArgument<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
@@ -80,7 +73,6 @@ export declare function getFunctionArguments(node: RFunctionCall<ParentInformati
 export declare function getUnresolvedSymbolsInExpression(expression: RNode<ParentInformation> | typeof EmptyArgument | undefined, dfg?: DataflowGraph): string[];
 /**
  * Checks whether a list of arguments contains any critical argument.
- *
  * @param args     - The list of arguments to check
  * @param critical - The critical arguments to search for (as string or {@link FunctionParameterLocation}s)
  * @param info     - Argument resolve information
@@ -89,7 +81,6 @@ 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

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

@@ -24,7 +24,6 @@ const visitor_1 = require("../../../r-bridge/lang-4.x/ast/model/processing/visit
 const ColNamesRegex = /^[A-Za-z.][A-Za-z0-9_.]*$/;
 /**
  * Escapes a regular expression given as string by escaping all special regular expression characters.
- *
  * @param text        - The text to escape
  * @param allowTokens - Whether to allow and keep unescaped tokens like `\s`, `\t`, or `\n`
  * @returns The escaped text
@@ -39,7 +38,6 @@ function escapeRegExp(text, allowTokens = false) {
 }
 /**
  * Maps all invalid, duplicate, or empty column names to top depending on the provided arguments.
- *
  * @param colnames     - The columns names to filter
  * @param checkNames   - Whether to map all invalid column names to top (`undefined`)
  * @param noDupNames   - Whether to map all duplicate column names to top (`undefined`)
@@ -60,7 +58,6 @@ function filterValidNames(colnames, checkNames, noDupNames, noEmptyNames) {
 }
 /**
  * Gets the value of an argument that specified as {@link FunctionParameterLocation}.
- *
  * @param args     - The arguments to get the requested argument from
  * @param argument - The specification of the argument to get the value for
  * @param info     - Argument resolve information
@@ -73,7 +70,6 @@ function getArgumentValue(args, argument, info) {
 }
 /**
  * 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
@@ -83,7 +79,6 @@ function getEffectiveArgs(args, excluded) {
 }
 /**
  * Gets an argument specified as {@link FunctionParameterLocation} from a list of arguments.
- *
  * @param args     - The arguments to get the requested argument from
  * @param argument - The specification of the argument to get
  * @param info     - Argument resolve information
@@ -104,7 +99,6 @@ function getFunctionArgument(args, argument, info) {
 }
 /**
  * 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
@@ -142,7 +136,6 @@ function getUnresolvedSymbolsInExpression(expression, dfg) {
 }
 /**
  * Checks whether a list of arguments contains any critical argument.
- *
  * @param args     - The list of arguments to check
  * @param critical - The critical arguments to search for (as string or {@link FunctionParameterLocation}s)
  * @param info     - Argument resolve information

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

@@ -7,7 +7,6 @@ import type { DataFrameAssignmentInfo } from '../absint-info';
 /**
  * Maps a concrete data frame assignment to data frame assignment info containing the ids of the identifier and assigned expression.
  * We currently do not support function assignments dealing with data frames.
- *
  * @param identifier - The R node of the variable identifier
  * @param expression - The R node of the assigned expression
  * @param dfg  - The data flow graph for resolving the arguments

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

@@ -8,7 +8,6 @@ const arguments_1 = require("./arguments");
 /**
  * Maps a concrete data frame assignment to data frame assignment info containing the ids of the identifier and assigned expression.
  * We currently do not support function assignments dealing with data frames.
- *
  * @param identifier - The R node of the variable identifier
  * @param expression - The R node of the assigned expression
  * @param dfg  - The data flow graph for resolving the arguments

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

@@ -1,11 +1,11 @@
-import type { FlowrConfigOptions } from '../../../config';
 import { type ResolveInfo } from '../../../dataflow/eval/resolve/alias-tracking';
 import type { DataflowGraph } from '../../../dataflow/graph/graph';
 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 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 { FunctionParameterLocation } from './arguments';
+import { type FunctionParameterLocation } from './arguments';
+import type { ReadOnlyFlowrAnalyzerContext } from '../../../project/context/flowr-analyzer-context';
 /**
  * Represents the different types of data frames in R
  */
@@ -179,13 +179,12 @@ declare const DataFrameFunctionMapper: {
 type DataFrameFunction = keyof typeof DataFrameFunctionMapper;
 /**
  * Maps a concrete data frame function call to abstract data frame operations.
- *
- * @param node   - The R node of the function call
- * @param dfg    - The data flow graph for resolving the arguments
- * @param config - The flowR configuration to use
+ * @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
  */
-export declare function mapDataFrameFunctionCall<Name extends DataFrameFunction>(node: RNode<ParentInformation>, dfg: DataflowGraph, config: FlowrConfigOptions): DataFrameExpressionInfo | undefined;
+export declare function mapDataFrameFunctionCall<Name extends DataFrameFunction>(node: RNode<ParentInformation>, dfg: DataflowGraph, ctx: ReadOnlyFlowrAnalyzerContext): DataFrameExpressionInfo | undefined;
 declare function mapDataFrameCreate(args: readonly RFunctionArgument<ParentInformation>[], params: {
     checkNames: FunctionParameterLocation<boolean>;
     noDupNames: FunctionParameterLocation<boolean>;
@@ -205,7 +204,7 @@ declare function mapDataFrameRead(args: readonly RFunctionArgument<ParentInforma
     checkNames: FunctionParameterLocation<boolean>;
     noDupNames: FunctionParameterLocation<boolean>;
     noEmptyNames?: boolean;
-}, info: ResolveInfo, config: FlowrConfigOptions): DataFrameOperation[];
+}, info: ResolveInfo, ctx: ReadOnlyFlowrAnalyzerContext): DataFrameOperation[];
 declare function mapDataFrameColBind(args: readonly RFunctionArgument<ParentInformation>[], params: {
     special: string[];
 }, info: ResolveInfo): DataFrameOperation[] | undefined;
@@ -252,7 +251,7 @@ declare function mapDataFrameJoin(args: readonly RFunctionArgument<ParentInforma
     joinAll: FunctionParameterLocation<boolean>;
     joinLeft: FunctionParameterLocation<boolean>;
     joinRight: FunctionParameterLocation<boolean>;
-}, info: ResolveInfo): DataFrameOperation[] | undefined;
+}, info: ResolveInfo, ctx: ReadOnlyFlowrAnalyzerContext): DataFrameOperation[] | undefined;
 declare function mapDataFrameIdentity(args: readonly RFunctionArgument<ParentInformation>[], params: {
     dataFrame: FunctionParameterLocation;
     special: string[];

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

@@ -9,7 +9,7 @@ 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 domain_1 = require("../domain");
+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");
@@ -519,13 +519,12 @@ const DataFrameFunctionParamsMapper = {
 };
 /**
  * Maps a concrete data frame function call to abstract data frame operations.
- *
- * @param node   - The R node of the function call
- * @param dfg    - The data flow graph for resolving the arguments
- * @param config - The flowR configuration to use
+ * @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
  */
-function mapDataFrameFunctionCall(node, dfg, config) {
+function mapDataFrameFunctionCall(node, dfg, ctx) {
     if (node.type !== type_1.RType.FunctionCall || !node.named) {
         return;
     }
@@ -540,7 +539,7 @@ function mapDataFrameFunctionCall(node, dfg, config) {
             operations = [{ operation: 'unknown', operand: undefined }];
         }
         else {
-            operations = mapper(args, params, resolveInfo, config);
+            operations = mapper(args, params, resolveInfo, ctx);
         }
     }
     else {
@@ -606,10 +605,10 @@ function mapDataFrameConvert(args, params, info) {
             operand: dataFrame.value.info.id
         }];
 }
-function mapDataFrameRead(args, params, info, config) {
+function mapDataFrameRead(args, params, info, ctx) {
     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, config);
+    const { source, request } = getRequestFromRead(fileNameArg, textArg, params, info, ctx);
     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);
@@ -619,7 +618,7 @@ function mapDataFrameRead(args, params, info, config) {
     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 || !config.abstractInterpretation.dataFrame.readLoadedData.readExternalFiles || !validArguments) {
+    if (request === undefined || !ctx.config.abstractInterpretation.dataFrame.readLoadedData.readExternalFiles || !validArguments) {
         return [{
                 operation: 'read',
                 operand: undefined,
@@ -644,7 +643,7 @@ function mapDataFrameRead(args, params, info, config) {
             }
         }
     };
-    const allLines = parseRequestContent(request, parseLine, config.abstractInterpretation.dataFrame.readLoadedData.maxReadLines);
+    const allLines = parseRequestContent(request, parseLine, ctx.config.abstractInterpretation.dataFrame.readLoadedData.maxReadLines);
     let colnames;
     if (header) {
         colnames = (0, arguments_1.filterValidNames)(firstLine, checkNames, noDupNames, params.noEmptyNames);
@@ -1003,8 +1002,11 @@ function mapDataFrameSummarize(args, params, info) {
     }
     const result = [];
     const summarizeArgs = args.filter(arg => arg !== dataFrame);
-    const accessedNames = summarizeArgs.flatMap(arg => (0, arguments_1.getUnresolvedSymbolsInExpression)(arg, info.graph));
     const summarizedCols = summarizeArgs.map(arg => (0, resolve_args_1.resolveIdToArgName)(arg, info));
+    // only column names that are not created by summarize are preconditions on the operand
+    const accessedNames = summarizeArgs
+        .flatMap(arg => (0, arguments_1.getUnresolvedSymbolsInExpression)(arg, info.graph))
+        .filter(arg => !summarizedCols.includes(arg));
     if (accessedNames.length > 0) {
         result.push({
             operation: 'accessCols',
@@ -1019,7 +1021,7 @@ function mapDataFrameSummarize(args, params, info) {
     });
     return result;
 }
-function mapDataFrameJoin(args, params, info) {
+function mapDataFrameJoin(args, params, info, ctx) {
     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);
@@ -1036,7 +1038,7 @@ function mapDataFrameJoin(args, params, info) {
     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) ?? domain_1.DataFrameTop;
+    const otherDataFrame = (0, shape_inference_1.resolveIdToDataFrameShape)(otherArg, info.graph) ?? dataframe_domain_1.DataFrameDomain.top(ctx.config.abstractInterpretation.dataFrame.maxColNames);
     let byCols;
     const joinType = getJoinType(joinAll, joinLeft, joinRight);
     if (byArg !== undefined) {
@@ -1102,19 +1104,19 @@ function mapDataFrameUnknown(args, params, info) {
             ...(params.constraintType !== undefined ? { type: params.constraintType } : {})
         }];
 }
-function getRequestFromRead(fileNameArg, textArg, params, info, config) {
+function getRequestFromRead(fileNameArg, textArg, params, info, ctx) {
     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') {
             source = fileName;
-            const referenceChain = fileNameArg.info.file ? [(0, retriever_1.requestFromInput)(`file://${fileNameArg.info.file}`)] : [];
-            const sources = (0, built_in_source_1.findSource)(config.solver.resolveSource, fileName, { referenceChain });
+            const referenceChain = fileNameArg.info.file ? [fileNameArg.info.file] : [];
+            const sources = (0, built_in_source_1.findSource)(ctx.config.solver.resolveSource, fileName, { referenceChain, ctx });
             if (sources?.length === 1) {
                 source = sources[0];
                 // create request from resolved source file path
-                request = (0, built_in_source_1.getSourceProvider)().createRequest(source);
+                request = { request: 'file', content: sources[0] };
             }
             else if (params.text === undefined && (0, resolve_args_1.unescapeSpecialChars)(fileName).includes('\n')) {
                 // create request from string if file name argument contains newline
@@ -1129,6 +1131,7 @@ function getRequestFromRead(fileNameArg, textArg, params, info, config) {
             request = (0, retriever_1.requestFromInput)((0, resolve_args_1.unescapeSpecialChars)(text));
         }
     }
+    request = request ? ctx.files.resolveRequest(request).r : undefined;
     return { source, request };
 }
 function parseRequestContent(request, parser, maxLines) {

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

@@ -4,7 +4,6 @@ import type { ParentInformation } from '../../../r-bridge/lang-4.x/ast/model/pro
 import type { DataFrameExpressionInfo } from '../absint-info';
 /**
  * Maps a concrete data frame replacement function to abstract data frame operations.
- *
  * @param node - The R node of the replacement function
  * @param dfg  - The data flow graph for resolving the arguments
  * @returns Data frame expression info containing the mapped abstract data frame operations, or `undefined` if the node does not represent a data frame replacement function

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

@@ -19,7 +19,6 @@ const DataFrameReplacementFunctionMapper = {
 };
 /**
  * Maps a concrete data frame replacement function to abstract data frame operations.
- *
  * @param node - The R node of the replacement function
  * @param dfg  - The data flow graph for resolving the arguments
  * @returns Data frame expression info containing the mapped abstract data frame operations, or `undefined` if the node does not represent a data frame replacement function

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

@@ -1,4 +1,4 @@
-import type { ResolveInfo } from '../../dataflow/eval/resolve/alias-tracking';
+import { type ResolveInfo } from '../../dataflow/eval/resolve/alias-tracking';
 import type { RArgument } from '../../r-bridge/lang-4.x/ast/model/nodes/r-argument';
 import type { ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';

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

@@ -1,4 +1,4 @@
-import type { DataFrameDomain } from './domain';
+import { DataFrameDomain } from './dataframe-domain';
 /**
  * Represents the different types of resulting constraints that are inferred by abstract data frame operations.
  */
@@ -107,7 +107,7 @@ declare const DataFrameSemanticsMapper: {
 /** All available abstract data frame operations */
 export type DataFrameOperationName = keyof typeof DataFrameSemanticsMapper;
 /** The names of all abstract data frame operations */
-export declare const DataFrameOperationNames: DataFrameOperationName[];
+export declare const DataFrameOperationNames: readonly DataFrameOperationName[];
 /** The required arguments for an abstract data frame operation */
 export type DataFrameOperationArgs<N extends DataFrameOperationName> = Parameters<typeof DataFrameSemanticsMapper[N]['apply']>[1];
 /** The optional addition options for an abstract data frame operation */
@@ -115,7 +115,6 @@ export type DataFrameOperationOptions<N extends DataFrameOperationName> = Parame
 /**
  * Applies the abstract semantics of an abstract data frame operation with respect to the data frame shape domain.
  * This expects that all arguments have already been sanitized according to the original concrete data frame function (e.g. by replacing duplicate/invalid column names).
- *
  * @param operation - The name of the abstract operation to apply the semantics of
  * @param value     - The abstract data frame shape of the operand of the abstract operation
  * @param args      - The arguments for applying the abstract semantics of the abstract operation
@@ -209,5 +208,5 @@ declare function applyJoinSemantics(value: DataFrameDomain, { other, by }: {
     natural?: boolean;
 }): DataFrameDomain;
 declare function applyIdentitySemantics(value: DataFrameDomain, _args: {}): DataFrameDomain;
-declare function applyUnknownSemantics(_value: DataFrameDomain, _args: {}): DataFrameDomain;
+declare function applyUnknownSemantics(value: DataFrameDomain, _args: {}): DataFrameDomain;
 export {};