@eagleoutice/flowr 2.2.16 → 2.4.0

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

@@ -0,0 +1,107 @@
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+type Interval = [number, number];
+/** The bottom element (least element) of the positive interval domain representing no possible values, explicitly given as "bottom". */
+export declare const IntervalBottom = "bottom";
+/** The top element (greatest element) of the positive interval domain representing all possible values, defined as the interval from 0 to infinity. */
+export declare const IntervalTop: [0, number];
+/** The positive interval domain representing possible integer values. */
+export type IntervalDomain = Interval | typeof IntervalBottom;
+/** The bottom element (least element) of the column names domain representing no possible column name, defined as the empty list []. */
+export declare const ColNamesBottom: [];
+/** The top element (greatest element) of the column names domain representing all possible values, explicitly given as "top". */
+export declare const ColNamesTop = "top";
+/** The column names domain defined as bounded string set domain representing possible column names. */
+export type ColNamesDomain = string[] | typeof ColNamesTop;
+/**
+ * The data frame shape domain representing possible data frame shapes, defined as product domain of
+ * the {@link ColNamesDomain} for the columns names and {@link IntervalDomain} for the number of columns and rows.
+ * */
+export interface DataFrameDomain {
+    colnames: ColNamesDomain;
+    cols: IntervalDomain;
+    rows: IntervalDomain;
+}
+/**
+ * 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}.
+ */
+export declare const DataFrameBottom: {
+    readonly colnames: [];
+    readonly cols: "bottom";
+    readonly rows: "bottom";
+};
+/**
+ * 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}.
+ */
+export declare const DataFrameTop: {
+    readonly colnames: "top";
+    readonly cols: [0, number];
+    readonly rows: [0, number];
+};
+/**
+ * The data frame shape state domain representing possible memory states, mapping AST node IDs to data frame shape values of the {@link DataFrameDomain}.
+ */
+export type DataFrameStateDomain = Map<NodeId, DataFrameDomain>;
+/** Checks if two abstract values of the column names domain are equal. */
+export declare function equalColNames(set1: ColNamesDomain, set2: ColNamesDomain): boolean;
+/** Checks if two abstract values of the column names domain are ordered according to the partial ordering of the column names lattice. */
+export declare function leqColNames(set1: ColNamesDomain, set2: ColNamesDomain): boolean;
+/** Joins two abstract values of the columns names domain according to the column names lattice by creating the least upper bound (LUB). */
+export declare function joinColNames(set1: ColNamesDomain, set2: ColNamesDomain, maxColNames?: number): ColNamesDomain;
+/** Meets two abstract values of the columns names domain according to the column names lattice by creating the greatest lower bound (GLB). */
+export declare function meetColNames(set1: ColNamesDomain, set2: ColNamesDomain): ColNamesDomain;
+/** Subtracts an abstract value from another abstract value of the column names domain by performing a set minus. */
+export declare function subtractColNames(set1: ColNamesDomain, set2: ColNamesDomain): ColNamesDomain;
+/**
+ * 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.
+ */
+export declare function wideningColNames(set1: ColNamesDomain, set2: ColNamesDomain): ColNamesDomain;
+/** Checks whether an abstract value of the column names domain satisfies a column name */
+export declare function satisfiesColsNames(set: ColNamesDomain, value: string): boolean;
+/** Checks if two abstract values of the positive interval domain are equal. */
+export declare function equalInterval(interval1: IntervalDomain, interval2: IntervalDomain): boolean;
+/** Checks if two abstract values of the positive interval domain are ordered according to the partial ordering of the positive interval lattice. */
+export declare function leqInterval(interval1: IntervalDomain, interval2: IntervalDomain): boolean;
+/** Joins two abstract values of the positive interval domain according to the positive interval lattice by creating the least upper bound (LUB). */
+export declare function joinInterval(interval1: IntervalDomain, interval2: IntervalDomain): IntervalDomain;
+/** Meets two abstract values of the positive interval domain according to the positive interval lattice by creating the greatest lower bound (GLB). */
+export declare function meetInterval(interval1: IntervalDomain, interval2: IntervalDomain): IntervalDomain;
+/** Adds two abstract values of the positive interval domain, by adding the lower bounds and upper bounds. */
+export declare function addInterval(interval1: IntervalDomain, interval2: IntervalDomain): IntervalDomain;
+/** Subtracts an abstract value from another abstract values of the positive interval domain, by subtracting the lower bounds and upper bounds. */
+export declare function subtractInterval(interval1: IntervalDomain, interval2: IntervalDomain): IntervalDomain;
+/** Creates the minium of two abstract values of the positive interval domain, by creating the minimum of the lower bounds and upper bounds. */
+export declare function minInterval(interval1: IntervalDomain, interval2: IntervalDomain): IntervalDomain;
+/** Creates the maximum of two abstract values of the positive interval domain, by creating the maximum of the lower bounds and upper bounds. */
+export declare function maxInterval(interval1: IntervalDomain, interval2: IntervalDomain): IntervalDomain;
+/** Extrends the lower bound of an abstract value of the positive interval domain to 0. */
+export declare function extendIntervalToZero(interval: IntervalDomain): IntervalDomain;
+/** Extrends the upper bound of an abstract value of the positive interval domain to infinity. */
+export declare function extendIntervalToInfinity(interval: IntervalDomain): IntervalDomain;
+/** Widens two abstract values of the positive interval domain via naive widening to soundly over-approximate the join in (possibly infinite) fixpoint iterations. */
+export declare function wideningInterval(interval1: IntervalDomain, interval2: IntervalDomain): IntervalDomain;
+/** Checks whether an abstract value of the positive interval domain satisfies a numeric value. */
+export declare function satisfiesInterval(interval: IntervalDomain, value: number): boolean;
+/** Checks whether a numeric value satisfies the less-than relation with an abstract value of the positive interval domain. */
+export declare function satisfiesLeqInterval(interval: IntervalDomain, value: number): boolean;
+/** Checks if two abstract values of the data frame shape domain are equal. */
+export declare function equalDataFrameDomain(value1: DataFrameDomain, value2: DataFrameDomain): boolean;
+/** Joins multiple abstract values of the data frame shape domain by creating the least upper bound (LUB). */
+export declare function joinDataFrames(...values: DataFrameDomain[]): DataFrameDomain;
+/** Meets multiple abstract values of the data frame shape domain by creating the greatest lower bound (GLB). */
+export declare function meetDataFrames(...values: DataFrameDomain[]): DataFrameDomain;
+/** Widens two abstract values of the data frame shape domain by widening the column names and number of columns and rows. */
+export declare function wideningDataFrames(value1: DataFrameDomain, value2: DataFrameDomain): DataFrameDomain;
+/** Checks if two abstract states of the data frame shape state domain are equal. */
+export declare function equalDataFrameState(state1: DataFrameStateDomain, state2: DataFrameStateDomain): boolean;
+/** Joins multiple abstract states of the data frame shape state domain by joining each data frame shape of the states. */
+export declare function joinDataFrameStates(...states: DataFrameStateDomain[]): DataFrameStateDomain;
+/** Meets multiple abstract states of the data frame shape state domain by meeting each data frame shape of the states. */
+export declare function meetDataFrameStates(...states: DataFrameStateDomain[]): DataFrameStateDomain;
+/** Widens two abstract states of the data frame shape state domain by widening each data frame shape of the states. */
+export declare function wideningDataFrameStates(state1: DataFrameStateDomain, state2: DataFrameStateDomain): DataFrameStateDomain;
+export {};

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