@eagleoutice/flowr 2.2.16 → 2.3.0

package/dataflow/eval/resolve/resolve.js

@@ -2,17 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveNode = resolveNode;
 exports.resolveAsVector = resolveAsVector;
+exports.resolveAsSeq = resolveAsSeq;
+exports.resolveAsPlus = resolveAsPlus;
+exports.resolveAsMinus = resolveAsMinus;
 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 assert_1 = require("../../../util/assert");
+const r_value_1 = require("../../../util/r-value");
 const built_in_1 = require("../../environments/built-in");
 const dfg_get_origin_1 = require("../../origin/dfg-get-origin");
 const interval_constants_1 = require("../values/intervals/interval-constants");
 const logical_constants_1 = require("../values/logical/logical-constants");
-const r_value_1 = require("../values/r-value");
+const r_value_2 = require("../values/r-value");
 const string_constants_1 = require("../values/string/string-constants");
 const vector_constants_1 = require("../values/vectors/vector-constants");
 const alias_tracking_1 = require("./alias-tracking");
+const scalar_consatnts_1 = require("../values/scalar/scalar-consatnts");
 /**
  * Helper function used by {@link resolveIdToValue}, please use that instead, if
  * you want to resolve the value of an identifier / node
@@ -37,59 +41,149 @@ function resolveNode(resolve, a, env, graph, map) {
     else if (a.type === type_1.RType.Logical) {
         return a.content.valueOf() ? logical_constants_1.ValueLogicalTrue : logical_constants_1.ValueLogicalFalse;
     }
-    else if (a.type === type_1.RType.FunctionCall && env && graph) {
+    else if ((a.type === type_1.RType.FunctionCall || a.type === type_1.RType.BinaryOp || a.type === type_1.RType.UnaryOp) && graph) {
         const origin = (0, dfg_get_origin_1.getOriginInDfg)(graph, a.info.id)?.[0];
         if (origin === undefined || origin.type !== 3 /* OriginType.BuiltInFunctionOrigin */) {
-            return r_value_1.Top;
+            return r_value_2.Top;
         }
-        if (origin.proc in built_in_1.BuiltInEvalHandlerMapper) {
-            const handler = built_in_1.BuiltInEvalHandlerMapper[origin.proc];
+        let builtInName;
+        if ((0, built_in_1.isBuiltIn)(origin.proc)) {
+            builtInName = origin.proc;
+        }
+        else if (a.type === type_1.RType.FunctionCall && a.named) {
+            builtInName = (0, built_in_1.builtInId)(a.functionName.content);
+        }
+        else if (a.type === type_1.RType.BinaryOp || a.type === type_1.RType.UnaryOp) {
+            builtInName = (0, built_in_1.builtInId)(a.operator);
+        }
+        else {
+            return r_value_2.Top;
+        }
+        if (Object.prototype.hasOwnProperty.call(built_in_1.BuiltInEvalHandlerMapper, builtInName)) {
+            const handler = built_in_1.BuiltInEvalHandlerMapper[builtInName];
             return handler(resolve, a, env, graph, map);
         }
     }
-    return r_value_1.Top;
+    return r_value_2.Top;
 }
 /**
  * Helper function used by {@link resolveIdToValue}, please use that instead, if
  * you want to resolve the value of an identifier / node
  *
- * This function converts an r-node to a Value Vector {@link vectorFrom}
- * It also recursively resolves any symbols, values, function calls (only c), in
- * order to construct the value of the vector to resolve by calling {@link resolveIdToValue}
- * or {@link resolveNode}
+ * This function resolves a vector function call `c` to a {@link ValueVector}
+ * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
  *
- * @param a       - Node of the vector to resolve
- * @param env     - Environment to use
  * @param resolve - Variable resolve mode
+ * @param node    - Node of the vector function to resolve
+ * @param env     - Environment to use
  * @param graph   - Dataflow graph
- * @param map     - Idmap of Dataflow Graph
+ * @param map     - Id map of the dataflow graph
  * @returns ValueVector or Top
  */
-function resolveAsVector(resolve, a, env, graph, map) {
-    (0, assert_1.guard)(a.type === type_1.RType.FunctionCall);
-    const values = [];
-    for (const arg of a.arguments) {
-        if (arg === r_function_call_1.EmptyArgument) {
-            continue;
-        }
-        if (arg.value === undefined) {
-            return r_value_1.Top;
-        }
-        if (arg.value.type === type_1.RType.Symbol) {
-            const value = (0, alias_tracking_1.resolveIdToValue)(arg.info.id, { environment: env, idMap: map, graph: graph, full: true, resolve });
-            if ((0, r_value_1.isTop)(value)) {
-                return r_value_1.Top;
-            }
-            values.push(value);
-        }
-        else {
-            const val = resolveNode(resolve, arg.value, env, graph, map);
-            if ((0, r_value_1.isTop)(val)) {
-                return r_value_1.Top;
-            }
-            values.push(val);
-        }
+function resolveAsVector(resolve, node, environment, graph, idMap) {
+    if (node.type !== type_1.RType.FunctionCall) {
+        return r_value_2.Top;
     }
+    const resolveInfo = { environment, graph, idMap, full: true, resolve };
+    const values = node.arguments.map(arg => arg !== r_function_call_1.EmptyArgument ? (0, alias_tracking_1.resolveIdToValue)(arg.value, resolveInfo) : r_value_2.Top);
     return (0, vector_constants_1.vectorFrom)((0, vector_constants_1.flattenVectorElements)(values));
 }
+/**
+ * Helper function used by {@link resolveIdToValue}, please use that instead, if
+ * you want to resolve the value of an identifier / node
+ *
+ * This function resolves a binary sequence operator `:` to a {@link ValueVector} of {@link ValueNumber}s
+ * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
+ *
+ * @param resolve  - Variable resolve mode
+ * @param operator - Node of the sequence operator to resolve
+ * @param env      - Environment to use
+ * @param graph    - Dataflow graph
+ * @param map      - Id map of the dataflow graph
+ * @returns ValueVector of ValueNumbers or Top
+ */
+function resolveAsSeq(resolve, operator, environment, graph, idMap) {
+    if (operator.type !== type_1.RType.BinaryOp) {
+        return r_value_2.Top;
+    }
+    const resolveInfo = { environment, graph, idMap, full: true, resolve };
+    const leftArg = (0, alias_tracking_1.resolveIdToValue)(operator.lhs, resolveInfo);
+    const rightArg = (0, alias_tracking_1.resolveIdToValue)(operator.rhs, resolveInfo);
+    const leftValue = (0, r_value_1.unliftRValue)(leftArg);
+    const rightValue = (0, r_value_1.unliftRValue)(rightArg);
+    if ((0, r_value_1.isRNumberValue)(leftValue) && (0, r_value_1.isRNumberValue)(rightValue)) {
+        return (0, vector_constants_1.vectorFrom)(createNumberSequence(leftValue, rightValue).map(scalar_consatnts_1.liftScalar));
+    }
+    return r_value_2.Top;
+}
+/**
+ * Helper function used by {@link resolveIdToValue}, please use that instead, if
+ * you want to resolve the value of an identifier / node
+ *
+ * This function resolves a unary plus operator `+` to a {@link ValueNumber} or {@link ValueVector} of ValueNumbers
+ * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
+ *
+ * @param resolve  - Variable resolve mode
+ * @param operator - Node of the plus operator to resolve
+ * @param env      - Environment to use
+ * @param graph    - Dataflow graph
+ * @param map      - Id map of the dataflow graph
+ * @returns ValueNumber, ValueVector of ValueNumbers, or Top
+ */
+function resolveAsPlus(resolve, operator, environment, graph, idMap) {
+    if (operator.type !== type_1.RType.UnaryOp) {
+        return r_value_2.Top;
+    }
+    const resolveInfo = { environment, graph, idMap, full: true, resolve };
+    const arg = (0, alias_tracking_1.resolveIdToValue)(operator.operand, resolveInfo);
+    const argValue = (0, r_value_1.unliftRValue)(arg);
+    if ((0, r_value_1.isRNumberValue)(argValue)) {
+        return (0, scalar_consatnts_1.liftScalar)(argValue);
+    }
+    else if (Array.isArray(argValue) && argValue.every(r_value_1.isRNumberValue)) {
+        return (0, vector_constants_1.vectorFrom)(argValue.map(scalar_consatnts_1.liftScalar));
+    }
+    return r_value_2.Top;
+}
+/**
+ * Helper function used by {@link resolveIdToValue}, please use that instead, if
+ * you want to resolve the value of an identifier / node
+ *
+ * This function resolves a unary minus operator `-` to a {@link ValueNumber} or {@link ValueVector} of ValueNumbers
+ * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
+ *
+ * @param resolve  - Variable resolve mode
+ * @param operator - Node of the minus operator to resolve
+ * @param env      - Environment to use
+ * @param graph    - Dataflow graph
+ * @param map      - Id map of the dataflow graph
+ * @returns ValueNumber, ValueVector of ValueNumbers, or Top
+ */
+function resolveAsMinus(resolve, operator, environment, graph, idMap) {
+    if (operator.type !== type_1.RType.UnaryOp) {
+        return r_value_2.Top;
+    }
+    const resolveInfo = { environment, graph, idMap, full: true, resolve };
+    const arg = (0, alias_tracking_1.resolveIdToValue)(operator.operand, resolveInfo);
+    const argValue = (0, r_value_1.unliftRValue)(arg);
+    if ((0, r_value_1.isRNumberValue)(argValue)) {
+        return (0, scalar_consatnts_1.liftScalar)({ ...argValue, num: -argValue.num });
+    }
+    else if (Array.isArray(argValue) && argValue.every(r_value_1.isRNumberValue)) {
+        return (0, vector_constants_1.vectorFrom)(argValue.map(element => (0, scalar_consatnts_1.liftScalar)({ ...element, num: -element.num })));
+    }
+    return r_value_2.Top;
+}
+function createNumberSequence(start, end) {
+    const sequence = [];
+    const min = Math.min(start.num, end.num);
+    const max = Math.max(start.num, end.num);
+    for (let i = min; i <= max; i++) {
+        sequence.push({ ...start, num: i });
+    }
+    if (start > end) {
+        sequence.reverse();
+    }
+    return sequence;
+}
 //# sourceMappingURL=resolve.js.map

package/dataflow/internal/process/functions/call/built-in/built-in-source.d.ts

@@ -8,6 +8,7 @@ import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/
 import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { NoInfo } from '../../../../../../r-bridge/lang-4.x/ast/model/model';
+export declare function getSourceProvider(): RParseRequestProvider;
 export declare function setSourceProvider(provider: RParseRequestProvider): void;
 export declare function inferWdFromScript(option: InferWorkingDirectory, referenceChain: readonly RParseRequest[]): string[];
 /**

package/dataflow/internal/process/functions/call/built-in/built-in-source.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSourceProvider = getSourceProvider;
 exports.setSourceProvider = setSourceProvider;
 exports.inferWdFromScript = inferWdFromScript;
 exports.findSource = findSource;
@@ -30,6 +31,9 @@ const r_value_1 = require("../../../../../eval/values/r-value");
 const unknown_side_effect_1 = require("../../../../../graph/unknown-side-effect");
 const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
 let sourceProvider = (0, retriever_1.requestProviderFromFile)();
+function getSourceProvider() {
+    return sourceProvider;
+}
 function setSourceProvider(provider) {
     sourceProvider = provider;
 }

package/documentation/doc-util/doc-query.js

@@ -17,6 +17,7 @@ const doc_dfg_1 = require("./doc-dfg");
 const doc_code_1 = require("./doc-code");
 const time_1 = require("../../util/text/time");
 const query_print_1 = require("../../queries/query-print");
+const doc_cli_option_1 = require("./doc-cli-option");
 const config_1 = require("../../config");
 async function showQuery(shell, code, queries, { showCode, collapseResult, collapseQuery, addOutput = () => '' } = {}) {
     const now = performance.now();
@@ -34,6 +35,15 @@ The analysis required _${(0, time_1.printAsMs)(duration)}_ (including parsing an
 
 ${(0, doc_code_1.codeBlock)('json', collapseQuery ? str.split('\n').join(' ').replace(/([{[])\s{2,}/g, '$1 ').replace(/\s{2,}([\]}])/g, ' $1') : str)}
 
+${(function () {
+        if (queries.length === 1 && Object.keys(queries[0]).length === 1) {
+            return `(This query can be shortened to \`@${queries[0].type}\` when used within the REPL command ${(0, doc_cli_option_1.getReplCommand)('query')}).`;
+        }
+        else {
+            return '';
+        }
+    })()}
+
 ${collapseResult ? ' <details> <summary style="color:gray">Show Results</summary>' : ''}
 
 _Results (prettified and summarized):_

package/documentation/print-interface-wiki.js

@@ -182,6 +182,7 @@ The following summarizes the configuration options:
 - \`solver\`: allows to configure how _flowR_ resolves variables and their values (currently we support: ${Object.values(config_1.VariableResolve).map(v => `\`${v}\``).join(', ')}), as well as if pointer analysis should be active.
 - \`engines\`: allows to configure the engines used by _flowR_ to interact with R code. See the [Engines wiki page](${doc_files_1.FlowrWikiBaseRef}/Engines) for more information.
 - \`defaultEngine\`: allows to specify the default engine to use for interacting with R code. If not set, an arbitrary engine from the specified list will be used.
+- \`abstractInterpretation\`: allows to configure how _flowR_ performs abstract interpretation, although we currently only support data frame shape inference through abstract interpretation.
 
 So you can configure _flowR_ by adding a file like the following:
 
@@ -214,6 +215,16 @@ ${(0, doc_code_1.codeBlock)('json', JSON.stringify({
             slicer: {
                 threshold: 50
             }
+        },
+        abstractInterpretation: {
+            dataFrame: {
+                maxColNames: 20,
+                wideningThreshold: 4,
+                readLoadedData: {
+                    readExternalFiles: true,
+                    maxReadLines: 1_000_000
+                }
+            }
         }
     }, null, 2))}
 

package/documentation/print-linter-wiki.js

@@ -107,6 +107,10 @@ print(x)
     rule(shell, 'naming-convention', 'NamingConventionConfig', 'NAMING_CONVENTION', 'lint-naming-convention', `
 myVar <- 42
 print(myVar)
+`, tagTypes);
+    rule(shell, 'dataframe-access-validation', 'DataFrameAccessValidationConfig', 'DATA_FRAME_ACCESS_VALIDATION', 'lint-dataframe-access-validation', `
+df <- data.frame(id = 1:5, name = 6:10)
+df[6, "value"]
 `, tagTypes);
     function rule(shell, name, configType, ruleType, testfile, example, types) {
         const rule = linter_rules_1.LintingRules[name];

package/documentation/print-query-wiki.js

@@ -36,6 +36,7 @@ const doc_types_1 = require("./doc-util/doc-types");
 const path_1 = __importDefault(require("path"));
 const control_flow_query_executor_1 = require("../queries/catalog/control-flow-query/control-flow-query-executor");
 const doc_cfg_1 = require("./doc-util/doc-cfg");
+const df_shape_query_executor_1 = require("../queries/catalog/df-shape-query/df-shape-query-executor");
 (0, doc_query_1.registerQueryDocumentation)('call-context', {
     name: 'Call-Context Query',
     type: 'active',
@@ -333,6 +334,22 @@ ${await (0, doc_query_1.showQuery)(shell, exampleCode, [{
 This query provides access to the current configuration of the flowR instance. See the [Interface](${doc_files_1.FlowrWikiBaseRef}/Interface) wiki page for more information on what the configuration represents.`;
     }
 });
+(0, doc_query_1.registerQueryDocumentation)('df-shape', {
+    name: 'Dataframe Shape Inference Query',
+    type: 'active',
+    shortDescription: 'Returns the shapes inferred for all dataframes in the code.',
+    functionName: df_shape_query_executor_1.executeDfShapeQuery.name,
+    functionFile: '../queries/catalog/df-shape-query/df-shape-query-format.ts',
+    buildExplanation: async (shell) => {
+        const exampleCode = 'x <- data.frame(a=1:3)\nfilter(x, FALSE)';
+        return `
+This query infers all shapes of dataframes within the code. For example, you can use:
+${await (0, doc_query_1.showQuery)(shell, exampleCode, [{
+                type: 'df-shape'
+            }], { showCode: true, collapseQuery: true })}
+`;
+    }
+});
 (0, doc_query_1.registerQueryDocumentation)('compound', {
     name: 'Compound Query',
     type: 'virtual',

package/linter/linter-rules.d.ts

@@ -89,7 +89,7 @@ export declare const LintingRules: {
     readonly 'absolute-file-paths': {
         readonly createSearch: (config: import("./rules/absolute-path").AbsoluteFilePathConfig) => import("../search/flowr-search-builder").FlowrSearchBuilder<"from-query", ["unique"], import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>>;
         readonly processSearchResult: (elements: import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, {
-            readonly query?: "config" | "origin" | "dataflow" | "search" | "call-context" | "control-flow" | "dataflow-lens" | "normalized-ast" | "id-map" | "dataflow-cluster" | "static-slice" | "lineage" | "dependencies" | "location-map" | "happens-before" | "resolve-value" | "project" | "linter" | undefined;
+            readonly query?: "config" | "origin" | "dataflow" | "search" | "call-context" | "control-flow" | "dataflow-lens" | "df-shape" | "normalized-ast" | "id-map" | "dataflow-cluster" | "static-slice" | "lineage" | "dependencies" | "location-map" | "happens-before" | "resolve-value" | "project" | "linter" | undefined;
             readonly queryResult?: import("../queries/base-query-format").BaseQueryResult | undefined;
             readonly node: import("../r-bridge/lang-4.x/ast/model/nodes/r-expression-list").RExpressionList<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation> | import("../r-bridge/lang-4.x/ast/model/nodes/r-function-definition").RFunctionDefinition<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation> | import("../r-bridge/lang-4.x/ast/model/nodes/r-function-call").RNamedFunctionCall<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation> | import("../r-bridge/lang-4.x/ast/model/nodes/r-function-call").RUnnamedFunctionCall<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation> | import("../r-bridge/lang-4.x/ast/model/nodes/r-parameter").RParameter<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation> | import("../r-bridge/lang-4.x/ast/model/nodes/r-argument").RArgument<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation> | import("../r-bridge/lang-4.x/ast/model/nodes/r-comment").RComment<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation> | import("../r-bridge/lang-4.x/ast/model/nodes/r-line-directive").RLineDirective<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation> | import("../r-bridge/lang-4.x/ast/model/nodes/r-for-loop").RForLoop<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation> | import("../r-bridge/lang-4.x/ast/model/nodes/r-repeat-loop").RRepeatLoop<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation> | import("../r-bridge/lang-4.x/ast/model/nodes/r-while-loop").RWhileLoop<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation> | import("../r-bridge/lang-4.x/ast/model/nodes/r-if-then-else").RIfThenElse<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation> | import("../r-bridge/lang-4.x/ast/model/nodes/r-access").RNamedAccess<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation> | import("../r-bridge/lang-4.x/ast/model/nodes/r-access").RIndexAccess<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation> | import("../r-bridge/lang-4.x/ast/model/nodes/r-unary-op").RUnaryOp<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation> | import("../r-bridge/lang-4.x/ast/model/nodes/r-binary-op").RBinaryOp<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation> | import("../r-bridge/lang-4.x/ast/model/nodes/r-symbol").RSymbol<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, string> | import("../r-bridge/lang-4.x/ast/model/nodes/r-number").RNumber<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation> | import("../r-bridge/lang-4.x/ast/model/nodes/r-string").RString<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation> | import("../r-bridge/lang-4.x/ast/model/nodes/r-logical").RLogical<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation> | import("../r-bridge/lang-4.x/ast/model/nodes/r-break").RBreak<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation> | import("../r-bridge/lang-4.x/ast/model/nodes/r-next").RNext<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation> | import("../r-bridge/lang-4.x/ast/model/nodes/r-pipe").RPipe<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>;
         }[]>, config: import("./rules/absolute-path").AbsoluteFilePathConfig, data: {
@@ -170,7 +170,30 @@ export declare const LintingRules: {
             readonly description: "Checks wether the symbols conform to a certain naming convention";
             readonly tags: readonly [import("./linter-tags").LintingRuleTag.Style, import("./linter-tags").LintingRuleTag.QuickFix];
             readonly defaultConfig: {
-                readonly caseing: import("./rules/naming-convention").CasingConvention.PascalCase;
+                readonly caseing: "auto";
+            };
+        };
+    };
+    readonly 'dataframe-access-validation': {
+        readonly createSearch: () => import("../search/flowr-search-builder").FlowrSearchBuilder<"all", ["with"], import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/search-executor/search-enrichers").EnrichedFlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>>;
+        readonly processSearchResult: (elements: import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, config: import("./rules/dataframe-access-validation").DataFrameAccessValidationConfig, data: {
+            normalize: import("../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+            dataflow: import("../dataflow/info").DataflowInformation;
+            config: import("../config").FlowrConfigOptions;
+        }) => {
+            results: import("./rules/dataframe-access-validation").DataFrameAccessValidationResult[];
+            '.meta': import("./rules/dataframe-access-validation").DataFrameAccessValidationMetadata;
+        };
+        readonly prettyPrint: {
+            readonly query: (result: import("./rules/dataframe-access-validation").DataFrameAccessValidationResult) => string;
+            readonly full: (result: import("./rules/dataframe-access-validation").DataFrameAccessValidationResult) => string;
+        };
+        readonly info: {
+            readonly name: "Dataframe Access Validation";
+            readonly tags: readonly [import("./linter-tags").LintingRuleTag.Bug, import("./linter-tags").LintingRuleTag.Usability, import("./linter-tags").LintingRuleTag.Reproducibility];
+            readonly description: "Validates the existance of accessed columns and rows of dataframes.";
+            readonly defaultConfig: {
+                readonly readLoadedData: false;
             };
         };
     };

package/linter/linter-rules.js

@@ -7,6 +7,7 @@ const absolute_path_1 = require("./rules/absolute-path");
 const unused_definition_1 = require("./rules/unused-definition");
 const seeded_randomness_1 = require("./rules/seeded-randomness");
 const naming_convention_1 = require("./rules/naming-convention");
+const dataframe_access_validation_1 = require("./rules/dataframe-access-validation");
 /**
  * The registry of currently supported linting rules.
  * A linting rule can be executed on a dataflow pipeline result using {@link executeLintingRule}.
@@ -17,6 +18,7 @@ exports.LintingRules = {
     'seeded-randomness': seeded_randomness_1.SEEDED_RANDOMNESS,
     'absolute-file-paths': absolute_path_1.ABSOLUTE_PATH,
     'unused-definitions': unused_definition_1.UNUSED_DEFINITION,
-    'naming-convention': naming_convention_1.NAMING_CONVENTION
+    'naming-convention': naming_convention_1.NAMING_CONVENTION,
+    'dataframe-access-validation': dataframe_access_validation_1.DATA_FRAME_ACCESS_VALIDATION
 };
 //# sourceMappingURL=linter-rules.js.map

package/linter/rules/absolute-path.d.ts

@@ -38,7 +38,7 @@ export interface AbsoluteFilePathMetadata extends MergeableRecord {
 export declare const ABSOLUTE_PATH: {
     readonly createSearch: (config: AbsoluteFilePathConfig) => import("../../search/flowr-search-builder").FlowrSearchBuilder<"from-query", ["unique"], ParentInformation, import("../../search/flowr-search").FlowrSearchElements<ParentInformation, import("../../search/flowr-search").FlowrSearchElement<ParentInformation>[]>>;
     readonly processSearchResult: (elements: import("../../search/flowr-search").FlowrSearchElements<ParentInformation, {
-        readonly query?: "config" | "origin" | "dataflow" | "search" | "call-context" | "control-flow" | "dataflow-lens" | "normalized-ast" | "id-map" | "dataflow-cluster" | "static-slice" | "lineage" | "dependencies" | "location-map" | "happens-before" | "resolve-value" | "project" | "linter" | undefined;
+        readonly query?: "config" | "origin" | "dataflow" | "search" | "call-context" | "control-flow" | "dataflow-lens" | "df-shape" | "normalized-ast" | "id-map" | "dataflow-cluster" | "static-slice" | "lineage" | "dependencies" | "location-map" | "happens-before" | "resolve-value" | "project" | "linter" | undefined;
         readonly queryResult?: import("../../queries/base-query-format").BaseQueryResult | undefined;
         readonly node: import("../../r-bridge/lang-4.x/ast/model/nodes/r-expression-list").RExpressionList<ParentInformation> | import("../../r-bridge/lang-4.x/ast/model/nodes/r-function-definition").RFunctionDefinition<ParentInformation> | import("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call").RNamedFunctionCall<ParentInformation> | import("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call").RUnnamedFunctionCall<ParentInformation> | import("../../r-bridge/lang-4.x/ast/model/nodes/r-parameter").RParameter<ParentInformation> | import("../../r-bridge/lang-4.x/ast/model/nodes/r-argument").RArgument<ParentInformation> | import("../../r-bridge/lang-4.x/ast/model/nodes/r-comment").RComment<ParentInformation> | import("../../r-bridge/lang-4.x/ast/model/nodes/r-line-directive").RLineDirective<ParentInformation> | import("../../r-bridge/lang-4.x/ast/model/nodes/r-for-loop").RForLoop<ParentInformation> | import("../../r-bridge/lang-4.x/ast/model/nodes/r-repeat-loop").RRepeatLoop<ParentInformation> | import("../../r-bridge/lang-4.x/ast/model/nodes/r-while-loop").RWhileLoop<ParentInformation> | import("../../r-bridge/lang-4.x/ast/model/nodes/r-if-then-else").RIfThenElse<ParentInformation> | import("../../r-bridge/lang-4.x/ast/model/nodes/r-access").RNamedAccess<ParentInformation> | import("../../r-bridge/lang-4.x/ast/model/nodes/r-access").RIndexAccess<ParentInformation> | import("../../r-bridge/lang-4.x/ast/model/nodes/r-unary-op").RUnaryOp<ParentInformation> | import("../../r-bridge/lang-4.x/ast/model/nodes/r-binary-op").RBinaryOp<ParentInformation> | import("../../r-bridge/lang-4.x/ast/model/nodes/r-symbol").RSymbol<ParentInformation, string> | import("../../r-bridge/lang-4.x/ast/model/nodes/r-number").RNumber<ParentInformation> | import("../../r-bridge/lang-4.x/ast/model/nodes/r-string").RString<ParentInformation> | import("../../r-bridge/lang-4.x/ast/model/nodes/r-logical").RLogical<ParentInformation> | import("../../r-bridge/lang-4.x/ast/model/nodes/r-break").RBreak<ParentInformation> | import("../../r-bridge/lang-4.x/ast/model/nodes/r-next").RNext<ParentInformation> | import("../../r-bridge/lang-4.x/ast/model/nodes/r-pipe").RPipe<ParentInformation>;
     }[]>, config: AbsoluteFilePathConfig, data: {

package/linter/rules/dataframe-access-validation.d.ts

@@ -0,0 +1,53 @@
+import type { ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { FlowrSearchElements } from '../../search/flowr-search';
+import { type MergeableRecord } from '../../util/objects';
+import { type SourceRange } from '../../util/range';
+import type { LintingResult } from '../linter-format';
+import { LintingRuleTag } from '../linter-tags';
+export interface DataFrameAccessValidationResult extends LintingResult {
+    /** The type of the data frame access ("column" or "row") */
+    type: 'column' | 'row';
+    /** The name or index of the column or row being accessed in the data frame */
+    accessed: string | number;
+    /** The name of the function/operation used for the access (e.g. `$`, `[`, `[[`, but also `filter`, `select`, ...) */
+    access: string;
+    /** The variable/symbol name of the accessed data frame operand (`undefined` if operand is no symbol) */
+    operand?: string;
+    /** The source range in the code where the access occurs */
+    range: SourceRange;
+}
+export interface DataFrameAccessValidationConfig extends MergeableRecord {
+    /** Whether data frame shapes should be extracted from loaded external data files, such as CSV files (defaults to the option in the flowR config if `undefined`) */
+    readLoadedData?: boolean;
+}
+export interface DataFrameAccessValidationMetadata extends MergeableRecord {
+    /** The number of data frame functions and operations containing inferred column or row accesses */
+    numOperations: number;
+    /** The number of inferred abstract column or row access operations */
+    numAccesses: number;
+    /** The total number of inferred accessed columns and rows */
+    totalAccessed: number;
+}
+export declare const DATA_FRAME_ACCESS_VALIDATION: {
+    readonly createSearch: () => import("../../search/flowr-search-builder").FlowrSearchBuilder<"all", ["with"], ParentInformation, FlowrSearchElements<ParentInformation, import("../../search/search-executor/search-enrichers").EnrichedFlowrSearchElement<ParentInformation>[]>>;
+    readonly processSearchResult: (elements: FlowrSearchElements<ParentInformation, import("../../search/flowr-search").FlowrSearchElement<ParentInformation>[]>, config: DataFrameAccessValidationConfig, data: {
+        normalize: import("../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+        dataflow: import("../../dataflow/info").DataflowInformation;
+        config: import("../../config").FlowrConfigOptions;
+    }) => {
+        results: DataFrameAccessValidationResult[];
+        '.meta': DataFrameAccessValidationMetadata;
+    };
+    readonly prettyPrint: {
+        readonly query: (result: DataFrameAccessValidationResult) => string;
+        readonly full: (result: DataFrameAccessValidationResult) => string;
+    };
+    readonly info: {
+        readonly name: "Dataframe Access Validation";
+        readonly tags: readonly [LintingRuleTag.Bug, LintingRuleTag.Usability, LintingRuleTag.Reproducibility];
+        readonly description: "Validates the existance of accessed columns and rows of dataframes.";
+        readonly defaultConfig: {
+            readonly readLoadedData: false;
+        };
+    };
+};

package/linter/rules/dataframe-access-validation.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DATA_FRAME_ACCESS_VALIDATION = void 0;
+const absint_info_1 = require("../../abstract-interpretation/data-frame/absint-info");
+const domain_1 = require("../../abstract-interpretation/data-frame/domain");
+const shape_inference_1 = require("../../abstract-interpretation/data-frame/shape-inference");
+const config_1 = require("../../config");
+const extract_cfg_1 = require("../../control-flow/extract-cfg");
+const type_1 = require("../../r-bridge/lang-4.x/ast/model/type");
+const flowr_search_builder_1 = require("../../search/flowr-search-builder");
+const search_enrichers_1 = require("../../search/search-executor/search-enrichers");
+const dfg_1 = require("../../util/mermaid/dfg");
+const range_1 = require("../../util/range");
+const linter_format_1 = require("../linter-format");
+const linter_tags_1 = require("../linter-tags");
+;
+;
+exports.DATA_FRAME_ACCESS_VALIDATION = {
+    createSearch: () => flowr_search_builder_1.Q.all().with(search_enrichers_1.Enrichment.CallTargets, { onlyBuiltin: true }),
+    processSearchResult: (elements, config, data) => {
+        const flowrConfig = (0, config_1.amendConfig)(data.config, flowrConfig => {
+            if (config.readLoadedData !== undefined) {
+                flowrConfig.abstractInterpretation.dataFrame.readLoadedData.readExternalFiles = config.readLoadedData;
+            }
+            return flowrConfig;
+        });
+        const cfg = (0, extract_cfg_1.extractCfg)(data.normalize, flowrConfig, data.dataflow.graph);
+        (0, shape_inference_1.inferDataFrameShapes)(cfg, data.dataflow.graph, data.normalize, flowrConfig);
+        const accessOperations = getAccessOperations(elements);
+        const accesses = [];
+        for (const [nodeId, operations] of accessOperations) {
+            const access = { nodeId };
+            for (const operation of operations) {
+                access.operand ??= operation.operand;
+                access.operandShape ??= (0, shape_inference_1.resolveIdToDataFrameShape)(operation.operand, data.dataflow.graph);
+                if (operation.operation === 'accessCols' && operation.columns !== undefined) {
+                    access.accessedCols ??= [];
+                    access.accessedCols.push(...operation.columns);
+                }
+                else if (operation.operation === 'accessRows' && operation.rows !== undefined) {
+                    access.accessedRows ??= [];
+                    access.accessedRows.push(...operation.rows);
+                }
+            }
+            accesses.push(access);
+        }
+        const operations = accessOperations.entries().flatMap(([, operations]) => operations).toArray();
+        const metadata = {
+            numOperations: accessOperations.size,
+            numAccesses: operations.length,
+            totalAccessed: operations
+                .map(operation => operation.operation === 'accessCols' ? operation.columns?.length ?? 0 : operation.rows?.length ?? 0)
+                .reduce((a, b) => a + b, 0)
+        };
+        const results = accesses
+            .flatMap(access => findInvalidDataFrameAccesses(access)
+            .map(accessed => ({ nodeId: access.nodeId, operand: access.operand, ...accessed })))
+            .map(({ nodeId, operand, ...accessed }) => ({
+            ...accessed,
+            node: data.normalize.idMap.get(nodeId),
+            operand: operand !== undefined ? data.normalize.idMap.get(operand) : undefined,
+        }))
+            .map(({ node, operand, ...accessed }) => ({
+            ...accessed,
+            access: node?.lexeme ?? '???',
+            ...(operand?.type === type_1.RType.Symbol ? { operand: operand.content } : {}),
+            range: node?.info.fullRange ?? node?.location ?? (0, range_1.rangeFrom)(-1, -1, -1, -1),
+            certainty: linter_format_1.LintingCertainty.Definitely
+        }));
+        return { results, '.meta': metadata };
+    },
+    prettyPrint: {
+        [linter_format_1.LintingPrettyPrintContext.Query]: result => `Access of ${result.type} ` +
+            (typeof result.accessed === 'string' ? `"${result.accessed}"` : result.accessed) + ' ' +
+            (result.operand !== undefined ? `of \`${result.operand}\`` : `at \`${result.access}\``) + ` at ${(0, dfg_1.formatRange)(result.range)}`,
+        [linter_format_1.LintingPrettyPrintContext.Full]: result => `Accessed ${result.type} ` +
+            (typeof result.accessed === 'string' ? `"${result.accessed}"` : result.accessed) + ' does not exist ' +
+            (result.operand !== undefined ? `in \`${result.operand}\`` : `at \`${result.access}\``) + ` at ${(0, dfg_1.formatRange)(result.range)}`
+    },
+    info: {
+        name: 'Dataframe Access Validation',
+        tags: [linter_tags_1.LintingRuleTag.Bug, linter_tags_1.LintingRuleTag.Usability, linter_tags_1.LintingRuleTag.Reproducibility],
+        description: 'Validates the existance of accessed columns and rows of dataframes.',
+        defaultConfig: { readLoadedData: false }
+    }
+};
+function getAccessOperations(elements) {
+    return new Map(elements.getElements()
+        .map(element => element.node)
+        .filter(absint_info_1.hasDataFrameExpressionInfo)
+        .map(node => [node.info.id, node.info.dataFrame.operations
+            .filter(({ operation }) => operation === 'accessCols' || operation === 'accessRows')
+            .map(({ operation, operand, type: _type, options: _options, ...args }) => ({ operation, operand, ...args }))
+    ])
+        .filter(([, operations]) => operations.length > 0));
+}
+function findInvalidDataFrameAccesses({ operandShape, accessedCols, accessedRows }) {
+    const invalidAccesses = [];
+    if (operandShape !== undefined) {
+        for (const row of accessedRows ?? []) {
+            if (!(0, domain_1.satisfiesLeqInterval)(operandShape.rows, row)) {
+                invalidAccesses.push({ type: 'row', accessed: row });
+            }
+        }
+        for (const col of accessedCols ?? []) {
+            if (typeof col === 'string' && !(0, domain_1.satisfiesColsNames)(operandShape.colnames, col)) {
+                invalidAccesses.push({ type: 'column', accessed: col });
+            }
+            else if (typeof col === 'number' && !(0, domain_1.satisfiesLeqInterval)(operandShape.cols, col)) {
+                invalidAccesses.push({ type: 'column', accessed: col });
+            }
+        }
+    }
+    return invalidAccesses;
+}
+//# sourceMappingURL=dataframe-access-validation.js.map

package/linter/rules/naming-convention.d.ts

@@ -65,7 +65,7 @@ export declare const NAMING_CONVENTION: {
         readonly description: "Checks wether the symbols conform to a certain naming convention";
         readonly tags: readonly [LintingRuleTag.Style, LintingRuleTag.QuickFix];
         readonly defaultConfig: {
-            readonly caseing: CasingConvention.PascalCase;
+            readonly caseing: "auto";
         };
     };
 };

package/linter/rules/naming-convention.js

@@ -66,11 +66,15 @@ function detectCasing(identifier) {
     return CasingConvention.Unknown;
 }
 function getMostUsedCasing(symbols) {
+    if (symbols.length === 0) {
+        return CasingConvention.Unknown;
+    }
     const map = new Map();
     for (const symbol of symbols) {
         const o = map.get(symbol.detectedCasing) ?? 0;
         map.set(symbol.detectedCasing, o + 1);
     }
+    // Return element with most occurances 
     return [...map].reduce((p, c) => p[1] > c[1] ? p : c)[0];
 }
 function fixCasing(identifier, convention) {
@@ -157,7 +161,7 @@ exports.NAMING_CONVENTION = {
         description: 'Checks wether the symbols conform to a certain naming convention',
         tags: [linter_tags_1.LintingRuleTag.Style, linter_tags_1.LintingRuleTag.QuickFix],
         defaultConfig: {
-            caseing: CasingConvention.PascalCase
+            caseing: 'auto'
         }
     }
 };