@eagleoutice/flowr 2.2.16 → 2.3.0

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

@@ -0,0 +1,315 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataFrameTop = exports.DataFrameBottom = exports.ColNamesTop = exports.ColNamesBottom = exports.IntervalTop = exports.IntervalBottom = void 0;
+exports.equalColNames = equalColNames;
+exports.leqColNames = leqColNames;
+exports.joinColNames = joinColNames;
+exports.meetColNames = meetColNames;
+exports.subtractColNames = subtractColNames;
+exports.wideningColNames = wideningColNames;
+exports.satisfiesColsNames = satisfiesColsNames;
+exports.equalInterval = equalInterval;
+exports.leqInterval = leqInterval;
+exports.joinInterval = joinInterval;
+exports.meetInterval = meetInterval;
+exports.addInterval = addInterval;
+exports.subtractInterval = subtractInterval;
+exports.minInterval = minInterval;
+exports.maxInterval = maxInterval;
+exports.extendIntervalToZero = extendIntervalToZero;
+exports.extendIntervalToInfinity = extendIntervalToInfinity;
+exports.wideningInterval = wideningInterval;
+exports.satisfiesInterval = satisfiesInterval;
+exports.satisfiesLeqInterval = satisfiesLeqInterval;
+exports.equalDataFrameDomain = equalDataFrameDomain;
+exports.joinDataFrames = joinDataFrames;
+exports.meetDataFrames = meetDataFrames;
+exports.wideningDataFrames = wideningDataFrames;
+exports.equalDataFrameState = equalDataFrameState;
+exports.joinDataFrameStates = joinDataFrameStates;
+exports.meetDataFrameStates = meetDataFrameStates;
+exports.wideningDataFrameStates = wideningDataFrameStates;
+const config_1 = require("../../config");
+const set_1 = require("../../util/collections/set");
+const MaxColNames = config_1.defaultConfigOptions.abstractInterpretation.dataFrame.maxColNames;
+/** The bottom element (least element) of the positive interval domain representing no possible values, explicitly given as "bottom". */
+exports.IntervalBottom = 'bottom';
+/** The top element (greatest element) of the positive interval domain representing all possible values, defined as the interval from 0 to infinity. */
+exports.IntervalTop = [0, Infinity];
+/** The bottom element (least element) of the column names domain representing no possible column name, defined as the empty list []. */
+exports.ColNamesBottom = [];
+/** The top element (greatest element) of the column names domain representing all possible values, explicitly given as "top". */
+exports.ColNamesTop = 'top';
+/**
+ * The bottom element (least element) of the data frame shape domain representing no possible value, mapping the columns names to {@link ColNamesBottom}
+ * and the number of columns and rows to {@link IntervalBottom}.
+ */
+exports.DataFrameBottom = {
+    colnames: exports.ColNamesBottom,
+    cols: exports.IntervalBottom,
+    rows: exports.IntervalBottom
+};
+/**
+ * The top element (greatest element) of the data frame shape domain representing all possible value, mapping the columns names to {@link ColNamesTop}
+ * and the number of columns and rows to {@link IntervalTop}.
+ */
+exports.DataFrameTop = {
+    colnames: exports.ColNamesTop,
+    cols: exports.IntervalTop,
+    rows: exports.IntervalTop
+};
+/** Checks if two abstract values of the column names domain are equal. */
+function equalColNames(set1, set2) {
+    return set1 === set2 || (set1 !== exports.ColNamesTop && set2 !== exports.ColNamesTop && (0, set_1.setEquals)(new Set(set1), new Set(set2)));
+}
+/** Checks if two abstract values of the column names domain are ordered according to the partial ordering of the column names lattice. */
+function leqColNames(set1, set2) {
+    return set2 === exports.ColNamesTop || (set1 !== exports.ColNamesTop && new Set(set1).isSubsetOf(new Set(set2)));
+}
+/** Joins two abstract values of the columns names domain according to the column names lattice by creating the least upper bound (LUB). */
+function joinColNames(set1, set2, maxColNames = MaxColNames) {
+    if (set1 === exports.ColNamesTop || set2 === exports.ColNamesTop) {
+        return exports.ColNamesTop;
+    }
+    const join = Array.from(new Set(set1).union(new Set(set2)));
+    return join.length > maxColNames ? exports.ColNamesTop : join;
+}
+/** Meets two abstract values of the columns names domain according to the column names lattice by creating the greatest lower bound (GLB). */
+function meetColNames(set1, set2) {
+    if (set1 === exports.ColNamesTop) {
+        return set2;
+    }
+    else if (set2 === exports.ColNamesTop) {
+        return set1;
+    }
+    else {
+        return Array.from(new Set(set1).intersection(new Set(set2)));
+    }
+}
+/** Subtracts an abstract value from another abstract value of the column names domain by performing a set minus. */
+function subtractColNames(set1, set2) {
+    if (set1 === exports.ColNamesTop) {
+        return exports.ColNamesTop;
+    }
+    else if (set2 === exports.ColNamesTop) {
+        return set1;
+    }
+    else {
+        return Array.from(new Set(set1).difference(new Set(set2)));
+    }
+}
+/**
+ * Widens two abstract values of the column names domain via naive widening to soundly over-approximate the join in (possibly infinite) fixpoint iterations.
+ *
+ * This is technically not necessary, as the join is limited by the maximum number of inferred column names.
+ * However, this speeds up the iteration in larger loops significantly, as we are over-approximating the column names much earlier.
+ */
+function wideningColNames(set1, set2) {
+    return leqColNames(set1, set2) ? set2 : exports.ColNamesTop;
+}
+/** Checks whether an abstract value of the column names domain satisfies a column name */
+function satisfiesColsNames(set, value) {
+    return set === exports.ColNamesTop || set.includes(value);
+}
+/** Checks if two abstract values of the positive interval domain are equal. */
+function equalInterval(interval1, interval2) {
+    return interval1 === interval2 || (interval1 !== exports.IntervalBottom && interval2 !== exports.IntervalBottom && interval1[0] === interval2[0] && interval1[1] === interval2[1]);
+}
+/** Checks if two abstract values of the positive interval domain are ordered according to the partial ordering of the positive interval lattice. */
+function leqInterval(interval1, interval2) {
+    return interval1 === exports.IntervalBottom || (interval2 !== exports.IntervalBottom && interval2[0] <= interval1[0] && interval1[1] <= interval2[1]);
+}
+/** Joins two abstract values of the positive interval domain according to the positive interval lattice by creating the least upper bound (LUB). */
+function joinInterval(interval1, interval2) {
+    if (interval1 === exports.IntervalBottom) {
+        return interval2;
+    }
+    else if (interval2 === exports.IntervalBottom) {
+        return interval1;
+    }
+    else {
+        return [Math.min(interval1[0], interval2[0]), Math.max(interval1[1], interval2[1])];
+    }
+}
+/** Meets two abstract values of the positive interval domain according to the positive interval lattice by creating the greatest lower bound (GLB). */
+function meetInterval(interval1, interval2) {
+    if (interval1 === exports.IntervalBottom || interval2 === exports.IntervalBottom) {
+        return exports.IntervalBottom;
+    }
+    else if (Math.max(interval1[0], interval2[0]) > Math.min(interval1[1], interval2[1])) {
+        return exports.IntervalBottom;
+    }
+    else {
+        return [Math.max(interval1[0], interval2[0]), Math.min(interval1[1], interval2[1])];
+    }
+}
+/** Adds two abstract values of the positive interval domain, by adding the lower bounds and upper bounds. */
+function addInterval(interval1, interval2) {
+    if (interval1 === exports.IntervalBottom || interval2 === exports.IntervalBottom) {
+        return exports.IntervalBottom;
+    }
+    else {
+        return [interval1[0] + interval2[0], interval1[1] + interval2[1]];
+    }
+}
+/** Subtracts an abstract value from another abstract values of the positive interval domain, by subtracting the lower bounds and upper bounds. */
+function subtractInterval(interval1, interval2) {
+    if (interval1 === exports.IntervalBottom || interval2 === exports.IntervalBottom) {
+        return exports.IntervalBottom;
+    }
+    else {
+        return [Math.max(interval1[0] - interval2[0], 0), Math.max(interval1[1] - interval2[1], 0)];
+    }
+}
+/** Creates the minium of two abstract values of the positive interval domain, by creating the minimum of the lower bounds and upper bounds. */
+function minInterval(interval1, interval2) {
+    if (interval1 === exports.IntervalBottom || interval2 === exports.IntervalBottom) {
+        return exports.IntervalBottom;
+    }
+    else {
+        return [Math.min(interval1[0], interval2[0]), Math.min(interval1[1], interval2[1])];
+    }
+}
+/** Creates the maximum of two abstract values of the positive interval domain, by creating the maximum of the lower bounds and upper bounds. */
+function maxInterval(interval1, interval2) {
+    if (interval1 === exports.IntervalBottom || interval2 === exports.IntervalBottom) {
+        return exports.IntervalBottom;
+    }
+    else {
+        return [Math.max(interval1[0], interval2[0]), Math.max(interval1[1], interval2[1])];
+    }
+}
+/** Extrends the lower bound of an abstract value of the positive interval domain to 0. */
+function extendIntervalToZero(interval) {
+    if (interval === exports.IntervalBottom) {
+        return exports.IntervalBottom;
+    }
+    else {
+        return [0, interval[1]];
+    }
+}
+/** Extrends the upper bound of an abstract value of the positive interval domain to infinity. */
+function extendIntervalToInfinity(interval) {
+    if (interval === exports.IntervalBottom) {
+        return exports.IntervalBottom;
+    }
+    else {
+        return [interval[0], Infinity];
+    }
+}
+/** Widens two abstract values of the positive interval domain via naive widening to soundly over-approximate the join in (possibly infinite) fixpoint iterations. */
+function wideningInterval(interval1, interval2) {
+    if (interval1 === exports.IntervalBottom) {
+        return interval2;
+    }
+    else if (interval2 === exports.IntervalBottom) {
+        return interval1;
+    }
+    else {
+        return [interval1[0] <= interval2[0] ? interval1[0] : 0, interval1[1] >= interval2[1] ? interval1[1] : Infinity];
+    }
+}
+/** Checks whether an abstract value of the positive interval domain satisfies a numeric value. */
+function satisfiesInterval(interval, value) {
+    return interval !== exports.IntervalBottom && interval[0] <= value && value <= interval[1];
+}
+/** Checks whether a numeric value satisfies the less-than relation with an abstract value of the positive interval domain. */
+function satisfiesLeqInterval(interval, value) {
+    return interval !== exports.IntervalBottom && value <= interval[1];
+}
+/** Checks if two abstract values of the data frame shape domain are equal. */
+function equalDataFrameDomain(value1, value2) {
+    return value1 === value2 || (equalColNames(value1.colnames, value2.colnames) && equalInterval(value1.cols, value2.cols) && equalInterval(value1.rows, value2.rows));
+}
+/** Joins multiple abstract values of the data frame shape domain by creating the least upper bound (LUB). */
+function joinDataFrames(...values) {
+    let result = values[0] ?? exports.DataFrameTop;
+    for (let i = 1; i < values.length; i++) {
+        result = {
+            colnames: joinColNames(result.colnames, values[i].colnames),
+            cols: joinInterval(result.cols, values[i].cols),
+            rows: joinInterval(result.rows, values[i].rows)
+        };
+    }
+    return result;
+}
+/** Meets multiple abstract values of the data frame shape domain by creating the greatest lower bound (GLB). */
+function meetDataFrames(...values) {
+    let result = values[0] ?? exports.DataFrameTop;
+    for (let i = 1; i < values.length; i++) {
+        result = {
+            colnames: meetColNames(result.colnames, values[i].colnames),
+            cols: meetInterval(result.cols, values[i].cols),
+            rows: meetInterval(result.rows, values[i].rows)
+        };
+    }
+    return result;
+}
+/** Widens two abstract values of the data frame shape domain by widening the column names and number of columns and rows. */
+function wideningDataFrames(value1, value2) {
+    return {
+        colnames: wideningColNames(value1.colnames, value2.colnames),
+        cols: wideningInterval(value1.cols, value2.cols),
+        rows: wideningInterval(value1.rows, value2.rows)
+    };
+}
+/** Checks if two abstract states of the data frame shape state domain are equal. */
+function equalDataFrameState(state1, state2) {
+    if (state1 === state2) {
+        return true;
+    }
+    else if (state1.size !== state2.size) {
+        return false;
+    }
+    for (const [nodeId, value] of state1) {
+        const other = state2.get(nodeId);
+        if (other === undefined || !equalDataFrameDomain(value, other)) {
+            return false;
+        }
+    }
+    return true;
+}
+/** Joins multiple abstract states of the data frame shape state domain by joining each data frame shape of the states. */
+function joinDataFrameStates(...states) {
+    const result = new Map(states[0]);
+    for (let i = 1; i < states.length; i++) {
+        for (const [nodeId, value] of states[i]) {
+            if (result.has(nodeId)) {
+                result.set(nodeId, joinDataFrames(result.get(nodeId) ?? exports.DataFrameTop, value));
+            }
+            else {
+                result.set(nodeId, value);
+            }
+        }
+    }
+    return result;
+}
+/** Meets multiple abstract states of the data frame shape state domain by meeting each data frame shape of the states. */
+function meetDataFrameStates(...states) {
+    const result = new Map(states[0]);
+    for (let i = 1; i < states.length; i++) {
+        for (const [nodeId, value] of states[i]) {
+            if (result.has(nodeId)) {
+                result.set(nodeId, meetDataFrames(result.get(nodeId) ?? exports.DataFrameTop, value));
+            }
+            else {
+                result.set(nodeId, value);
+            }
+        }
+    }
+    return result;
+}
+/** Widens two abstract states of the data frame shape state domain by widening each data frame shape of the states. */
+function wideningDataFrameStates(state1, state2) {
+    const result = new Map(state1);
+    for (const [nodeId, value] of state2) {
+        if (result.has(nodeId)) {
+            result.set(nodeId, wideningDataFrames(result.get(nodeId) ?? exports.DataFrameTop, value));
+        }
+        else {
+            result.set(nodeId, value);
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=domain.js.map

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

@@ -0,0 +1,17 @@
+import type { DataflowGraph } from '../../../dataflow/graph/graph';
+import type { RNode } from '../../../r-bridge/lang-4.x/ast/model/model';
+import type { RAccess, RNamedAccess } from '../../../r-bridge/lang-4.x/ast/model/nodes/r-access';
+import type { ParentInformation } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { DataFrameExpressionInfo } from '../absint-info';
+/**
+ * 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
+ */
+export declare function mapDataFrameAccess(node: RNode<ParentInformation>, dfg: DataflowGraph): DataFrameExpressionInfo | undefined;
+/**
+ * Checks whether an access node represents a string-based access (`$` or `@`), and no index-based access (`[` or `[[`).
+ */
+export declare function isStringBasedAccess(access: RAccess<ParentInformation>): access is RNamedAccess<ParentInformation>;

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

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapDataFrameAccess = mapDataFrameAccess;
+exports.isStringBasedAccess = isStringBasedAccess;
+const config_1 = require("../../../config");
+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");
+const arguments_1 = require("./arguments");
+/**
+ * Special named arguments of index-based access operators
+ */
+const SpecialAccessArgumentsMapper = {
+    '[': ['drop'],
+    '[[': ['exact']
+};
+/**
+ * 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
+ */
+function mapDataFrameAccess(node, dfg) {
+    if (node.type !== type_1.RType.Access) {
+        return;
+    }
+    const resolveInfo = { graph: dfg, idMap: dfg.idMap, full: true, resolve: config_1.VariableResolve.Alias };
+    let operations;
+    if (isStringBasedAccess(node)) {
+        operations = mapDataFrameNamedColumnAccess(node, resolveInfo);
+    }
+    else {
+        operations = mapDataFrameIndexColRowAccess(node, resolveInfo);
+    }
+    if (operations !== undefined) {
+        return { type: 'expression', operations: operations };
+    }
+}
+function mapDataFrameNamedColumnAccess(access, info) {
+    const dataFrame = access.accessed;
+    if (!(0, arguments_1.isDataFrameArgument)(dataFrame, info)) {
+        return;
+    }
+    const colname = (0, resolve_args_1.resolveIdToArgValueSymbolName)(access.access[0], info);
+    return [{
+            operation: 'accessCols',
+            operand: dataFrame.info.id,
+            columns: colname ? [colname] : undefined
+        }];
+}
+function mapDataFrameIndexColRowAccess(access, 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)) {
+        return;
+    }
+    else if (args.every(arg => arg === r_function_call_1.EmptyArgument)) {
+        return [{ operation: 'identity', operand: dataFrame.info.id }];
+    }
+    const result = [];
+    const rowArg = args.length < 2 ? undefined : args[0];
+    const colArg = args.length < 2 ? args[0] : args[1];
+    let rows = undefined;
+    let columns = undefined;
+    if (rowArg !== undefined && rowArg !== r_function_call_1.EmptyArgument) {
+        const rowValue = (0, resolve_args_1.resolveIdToArgValue)(rowArg, info);
+        if (typeof rowValue === 'number') {
+            rows = [rowValue];
+        }
+        else if (Array.isArray(rowValue) && rowValue.every(row => typeof row === 'number')) {
+            rows = rowValue;
+        }
+        result.push({
+            operation: 'accessRows',
+            operand: dataFrame.info.id,
+            rows: rows?.map(Math.abs)
+        });
+    }
+    if (colArg !== undefined && colArg !== r_function_call_1.EmptyArgument) {
+        const colValue = (0, resolve_args_1.resolveIdToArgValue)(colArg, info);
+        if (typeof colValue === 'number') {
+            columns = [colValue];
+        }
+        else if (typeof colValue === 'string' && exact !== false) {
+            columns = [colValue];
+        }
+        else if (Array.isArray(colValue) && colValue.every(col => typeof col === 'number')) {
+            columns = colValue;
+        }
+        else if (Array.isArray(colValue) && colValue.every(col => typeof col === 'string') && exact !== false) {
+            columns = colValue;
+        }
+        result.push({
+            operation: 'accessCols',
+            operand: dataFrame.info.id,
+            columns: columns?.every(col => typeof col === 'number') ? columns.map(Math.abs) : columns
+        });
+    }
+    // The data frame extent is dropped if the operator `[[` is used, the argument `drop` is true, or only one column is accessed
+    const dropExtent = access.operator === '[[' ? true :
+        args.length === 2 && typeof drop === 'boolean' ? drop :
+            rowArg !== undefined && columns?.length === 1 && (typeof columns[0] === 'string' || columns[0] > 0);
+    if (!dropExtent) {
+        const rowSubset = rows === undefined || rows.every(row => row >= 0);
+        const colSubset = columns === undefined || columns.every(col => typeof col === 'string' || col >= 0);
+        const rowZero = rows?.length === 1 && rows[0] === 0;
+        const colZero = columns?.length === 1 && columns[0] === 0;
+        const duplicateRows = rows?.some((row, index, list) => list.indexOf(row) !== index);
+        const duplicateCols = columns?.some((col, index, list) => list.indexOf(col) !== index);
+        let operand = dataFrame;
+        if (rowArg !== undefined && rowArg !== r_function_call_1.EmptyArgument) {
+            if (rowSubset) {
+                result.push({
+                    operation: 'subsetRows',
+                    operand: operand?.info.id,
+                    rows: rowZero ? 0 : rows?.filter(index => index !== 0).length,
+                    ...(duplicateRows ? { options: { duplicateRows: true } } : {})
+                });
+            }
+            else {
+                result.push({
+                    operation: 'removeRows',
+                    operand: operand?.info.id,
+                    rows: rowZero ? 0 : rows?.filter(index => index !== 0).length
+                });
+            }
+            operand = undefined;
+        }
+        if (colArg !== undefined && colArg !== r_function_call_1.EmptyArgument) {
+            if (colSubset) {
+                result.push({
+                    operation: 'subsetCols',
+                    operand: operand?.info.id,
+                    colnames: colZero ? [] : columns?.map(col => typeof col === 'string' ? col : undefined),
+                    ...(duplicateCols ? { options: { duplicateCols: true } } : {})
+                });
+            }
+            else {
+                result.push({
+                    operation: 'removeCols',
+                    operand: operand?.info.id,
+                    colnames: columns?.map(col => typeof col === 'string' ? col : undefined)
+                });
+            }
+            operand = undefined;
+        }
+    }
+    return result;
+}
+/**
+ * Removes all special named arguments from the arguments of an access operator (i.e. arguments like "drop" and "exact").
+ */
+function getAccessArgs(operator, args) {
+    const specialArgs = SpecialAccessArgumentsMapper[operator];
+    return args.filter(arg => arg === r_function_call_1.EmptyArgument || arg.name === undefined || !specialArgs.includes((0, resolve_args_1.unquoteArgument)(arg.name.content)));
+}
+/**
+ * Checks whether an access node represents a string-based access (`$` or `@`), and no index-based access (`[` or `[[`).
+ */
+function isStringBasedAccess(access) {
+    return access.operator === '$' || access.operator === '@';
+}
+//# sourceMappingURL=access-mapper.js.map

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

@@ -0,0 +1,117 @@
+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 { 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';
+/**
+ * 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)
+ * - `name` optionally contains the name of the function parameter
+ * - `default` optionally contains the default value of the function parameter
+ */
+export interface FunctionParameterLocation<T = never> {
+    pos: number;
+    name?: string;
+    default?: T;
+}
+/**
+ * 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
+ */
+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`)
+ * @param noEmptyNames - Whether to map all empty column names to top (`undefined`)
+ * @returns The filtered column names
+ */
+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
+ * @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;
+/**
+ * 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>[];
+/**
+ * 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
+ * @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;
+/**
+ * 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>[];
+/**
+ * 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
+ * @param dfg        - The data flow graph for checking the outgoing edges
+ * @returns The name of all unresolved symbols in the expression
+ */
+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
+ * @returns Whether the arguments contain any critical argument
+ */
+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
+ */
+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>>;
+};
+/**
+ * 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> & {
+    value: RSymbol<ParentInformation, typeof RNull>;
+};
+/**
+ * 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;