@eagleoutice/flowr 2.3.0 → 2.4.1

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

@@ -3,6 +3,7 @@ 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 { LintingRuleCertainty } from '../linter-format';
 import { LintingRuleTag } from '../linter-tags';
 export interface DataFrameAccessValidationResult extends LintingResult {
     /** The type of the data frame access ("column" or "row") */
@@ -29,7 +30,7 @@ export interface DataFrameAccessValidationMetadata extends MergeableRecord {
     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 createSearch: () => import("../../search/flowr-search-builder").FlowrSearchBuilder<"all", ["with"], ParentInformation, FlowrSearchElements<ParentInformation, import("../../search/flowr-search").FlowrSearchElement<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;
@@ -45,6 +46,7 @@ export declare const DATA_FRAME_ACCESS_VALIDATION: {
     readonly info: {
         readonly name: "Dataframe Access Validation";
         readonly tags: readonly [LintingRuleTag.Bug, LintingRuleTag.Usability, LintingRuleTag.Reproducibility];
+        readonly certainty: LintingRuleCertainty.BestEffort;
         readonly description: "Validates the existance of accessed columns and rows of dataframes.";
         readonly defaultConfig: {
             readonly readLoadedData: false;

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

@@ -65,7 +65,7 @@ exports.DATA_FRAME_ACCESS_VALIDATION = {
             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
+            certainty: linter_format_1.LintingResultCertainty.Certain
         }));
         return { results, '.meta': metadata };
     },
@@ -80,6 +80,8 @@ exports.DATA_FRAME_ACCESS_VALIDATION = {
     info: {
         name: 'Dataframe Access Validation',
         tags: [linter_tags_1.LintingRuleTag.Bug, linter_tags_1.LintingRuleTag.Usability, linter_tags_1.LintingRuleTag.Reproducibility],
+        // this rule is unable to detect all cases of dataframe access, but sufficiently ensures returned results are valid
+        certainty: linter_format_1.LintingRuleCertainty.BestEffort,
         description: 'Validates the existance of accessed columns and rows of dataframes.',
         defaultConfig: { readLoadedData: false }
     }

package/linter/rules/dead-code.d.ts

@@ -0,0 +1,43 @@
+import { LintingResultCertainty, type LintingResult, LintingRuleCertainty } from '../linter-format';
+import type { SourceRange } from '../../util/range';
+import type { MergeableRecord } from '../../util/objects';
+import { LintingRuleTag } from '../linter-tags';
+import { type CfgSimplificationPassName } from '../../control-flow/cfg-simplification';
+export interface DeadCodeResult extends LintingResult {
+    range: SourceRange;
+}
+export interface DeadCodeConfig extends MergeableRecord {
+    /**
+     * The simplification passes that should be run on the extracted CFG.
+     * Defaults to the entries of {@link DefaultCfgSimplificationOrder} and `analyze-dead-code`.
+     */
+    simplificationPasses?: CfgSimplificationPassName[];
+}
+export interface DeadCodeMetadata extends MergeableRecord {
+    consideredNodes: number;
+}
+export declare const DEAD_CODE: {
+    readonly createSearch: (config: DeadCodeConfig) => 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/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, import("../../search/flowr-search").FlowrSearchElement<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, _config: DeadCodeConfig, _data: {
+        normalize: import("../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+        dataflow: import("../../dataflow/info").DataflowInformation;
+        config: import("../../config").FlowrConfigOptions;
+    }) => {
+        results: {
+            certainty: LintingResultCertainty.Certain;
+            range: SourceRange;
+        }[];
+        '.meta': DeadCodeMetadata;
+    };
+    readonly prettyPrint: {
+        readonly query: (result: DeadCodeResult) => string;
+        readonly full: (result: DeadCodeResult) => string;
+    };
+    readonly info: {
+        readonly name: "Dead Code";
+        readonly tags: readonly [LintingRuleTag.Smell, LintingRuleTag.Usability, LintingRuleTag.Reproducibility];
+        readonly certainty: LintingRuleCertainty.BestEffort;
+        readonly description: "Marks areas of code that are never reached during execution.";
+        readonly defaultConfig: {};
+    };
+};

package/linter/rules/dead-code.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEAD_CODE = void 0;
+const linter_format_1 = require("../linter-format");
+const range_1 = require("../../util/range");
+const flowr_search_builder_1 = require("../../search/flowr-search-builder");
+const dfg_1 = require("../../util/mermaid/dfg");
+const linter_tags_1 = require("../linter-tags");
+const search_enrichers_1 = require("../../search/search-executor/search-enrichers");
+const assert_1 = require("../../util/assert");
+const cfg_simplification_1 = require("../../control-flow/cfg-simplification");
+exports.DEAD_CODE = {
+    createSearch: (config) => flowr_search_builder_1.Q.all().with(search_enrichers_1.Enrichment.CfgInformation, {
+        checkReachable: true,
+        simplificationPasses: config.simplificationPasses ?? [...cfg_simplification_1.DefaultCfgSimplificationOrder, 'analyze-dead-code']
+    }),
+    processSearchResult: (elements, _config, _data) => {
+        const meta = {
+            consideredNodes: 0
+        };
+        return {
+            results: (0, range_1.combineRanges)(...new Set(elements.getElements()
+                .filter(element => {
+                meta.consideredNodes++;
+                const cfgInformation = (0, search_enrichers_1.enrichmentContent)(element, search_enrichers_1.Enrichment.CfgInformation);
+                return cfgInformation.isRoot && !cfgInformation.isReachable;
+            })
+                .map(element => element.node.info.fullRange ?? element.node.location)
+                .filter(assert_1.isNotUndefined)))
+                .map(range => ({
+                certainty: linter_format_1.LintingResultCertainty.Certain,
+                range
+            })),
+            '.meta': meta
+        };
+    },
+    prettyPrint: {
+        [linter_format_1.LintingPrettyPrintContext.Query]: result => `Code at ${(0, dfg_1.formatRange)(result.range)}`,
+        [linter_format_1.LintingPrettyPrintContext.Full]: result => `Code at ${(0, dfg_1.formatRange)(result.range)} can never be executed`,
+    },
+    info: {
+        name: 'Dead Code',
+        tags: [linter_tags_1.LintingRuleTag.Smell, linter_tags_1.LintingRuleTag.Usability, linter_tags_1.LintingRuleTag.Reproducibility],
+        // our limited dead code analysis causes complex cases of dead code not to be included in the linting result, but deadness is properly investigated for returned results
+        certainty: linter_format_1.LintingRuleCertainty.BestEffort,
+        description: 'Marks areas of code that are never reached during execution.',
+        defaultConfig: {}
+    }
+};
+//# sourceMappingURL=dead-code.js.map

package/linter/rules/deprecated-functions.d.ts

@@ -1,5 +1,5 @@
 import type { LintingResult } from '../linter-format';
-import { LintingCertainty } from '../linter-format';
+import { LintingResultCertainty, LintingRuleCertainty } from '../linter-format';
 import type { MergeableRecord } from '../../util/objects';
 import type { SourceRange } from '../../util/range';
 import type { Identifier } from '../../dataflow/environments/identifier';
@@ -22,7 +22,7 @@ export declare const DEPRECATED_FUNCTIONS: {
     readonly createSearch: (config: DeprecatedFunctionsConfig) => import("../../search/flowr-search-builder").FlowrSearchBuilder<"all", ["with", "filter"], 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, import("../../search/flowr-search").FlowrSearchElement<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>) => {
         results: {
-            certainty: LintingCertainty.Definitely;
+            certainty: LintingResultCertainty.Certain;
             function: Identifier;
             range: SourceRange;
         }[];
@@ -35,6 +35,7 @@ export declare const DEPRECATED_FUNCTIONS: {
     readonly info: {
         readonly name: "Deprecated Functions";
         readonly tags: readonly [LintingRuleTag.Deprecated, LintingRuleTag.Smell, LintingRuleTag.Usability, LintingRuleTag.Reproducibility];
+        readonly certainty: LintingRuleCertainty.BestEffort;
         readonly description: "Marks deprecated functions that should not be used anymore.";
         readonly defaultConfig: {
             readonly deprecatedFunctions: readonly ["all_equal", "arrange_all", "distinct_all", "filter_all", "group_by_all", "summarise_all", "mutate_all", "select_all", "vars", "all_vars", "id", "failwith", "select_vars", "rename_vars", "select_var", "current_vars", "bench_tbls", "compare_tbls", "compare_tbls2", "eval_tbls", "eval_tbls2", "location", "changes", "combine", "do", "funs", "add_count_", "add_tally_", "arrange_", "count_", "distinct_", "do_", "filter_", "funs_", "group_by_", "group_indices_", "mutate_", "tally_", "transmute_", "rename_", "rename_vars_", "select_", "select_vars_", "slice_", "summarise_", "summarize_", "summarise_each", "src_local", "tbl_df", "add_rownames", "group_nest", "group_split", "with_groups", "nest_by", "progress_estimated", "recode", "sample_n", "top_n", "transmute", "fct_explicit_na", "aes_", "aes_auto", "annotation_logticks", "is.Coord", "coord_flip", "coord_map", "is.facet", "fortify", "is.ggproto", "guide_train", "is.ggplot", "qplot", "is.theme", "gg_dep", "liply", "isplit2", "list_along", "cross", "invoke", "at_depth", "prepend", "rerun", "splice", "`%@%`", "rbernoulli", "rdunif", "when", "update_list", "map_raw", "accumulate", "reduce_right", "flatten", "map_dfr", "as_vector", "transpose", "melt_delim", "melt_fwf", "melt_table", "read_table2", "str_interp", "as_tibble", "data_frame", "tibble_", "data_frame_", "lst_", "as_data_frame", "as.tibble", "frame_data", "trunc_mat", "is.tibble", "tidy_names", "set_tidy_names", "repair_names", "extract_numeric", "complete_", "drop_na_", "expand_", "crossing_", "nesting_", "extract_", "fill_", "gather_", "nest_", "separate_rows_", "separate_", "spread_", "unite_", "unnest_", "extract", "gather", "nest_legacy", "separate_rows", "separate", "spread"];

package/linter/rules/deprecated-functions.js

@@ -35,7 +35,7 @@ exports.DEPRECATED_FUNCTIONS = {
                 });
             })
                 .map(element => ({
-                certainty: linter_format_1.LintingCertainty.Definitely,
+                certainty: linter_format_1.LintingResultCertainty.Certain,
                 function: element.target,
                 range: element.range
             })),
@@ -49,6 +49,8 @@ exports.DEPRECATED_FUNCTIONS = {
     info: {
         name: 'Deprecated Functions',
         tags: [linter_tags_1.LintingRuleTag.Deprecated, linter_tags_1.LintingRuleTag.Smell, linter_tags_1.LintingRuleTag.Usability, linter_tags_1.LintingRuleTag.Reproducibility],
+        // ensures all deprecated functions found are actually deprecated through its limited config, but doesn't find all deprecated functions since the config is pre-crawled
+        certainty: linter_format_1.LintingRuleCertainty.BestEffort,
         description: 'Marks deprecated functions that should not be used anymore.',
         defaultConfig: {
             deprecatedFunctions: ['all_equal', 'arrange_all', 'distinct_all', 'filter_all', 'group_by_all', 'summarise_all', 'mutate_all', 'select_all', 'vars', 'all_vars', 'id', 'failwith', 'select_vars', 'rename_vars', 'select_var', 'current_vars', 'bench_tbls', 'compare_tbls', 'compare_tbls2', 'eval_tbls', 'eval_tbls2', 'location', 'changes', 'combine', 'do', 'funs', 'add_count_', 'add_tally_', 'arrange_', 'count_', 'distinct_', 'do_', 'filter_', 'funs_', 'group_by_', 'group_indices_', 'mutate_', 'tally_', 'transmute_', 'rename_', 'rename_vars_', 'select_', 'select_vars_', 'slice_', 'summarise_', 'summarize_', 'summarise_each', 'src_local', 'tbl_df', 'add_rownames', 'group_nest', 'group_split', 'with_groups', 'nest_by', 'progress_estimated', 'recode', 'sample_n', 'top_n', 'transmute', 'fct_explicit_na', 'aes_', 'aes_auto', 'annotation_logticks', 'is.Coord', 'coord_flip', 'coord_map', 'is.facet', 'fortify', 'is.ggproto', 'guide_train', 'is.ggplot', 'qplot', 'is.theme', 'gg_dep', 'liply', 'isplit2', 'list_along', 'cross', 'invoke', 'at_depth', 'prepend', 'rerun', 'splice', '`%@%`', 'rbernoulli', 'rdunif', 'when', 'update_list', 'map_raw', 'accumulate', 'reduce_right', 'flatten', 'map_dfr', 'as_vector', 'transpose', 'melt_delim', 'melt_fwf', 'melt_table', 'read_table2', 'str_interp', 'as_tibble', 'data_frame', 'tibble_', 'data_frame_', 'lst_', 'as_data_frame', 'as.tibble', 'frame_data', 'trunc_mat', 'is.tibble', 'tidy_names', 'set_tidy_names', 'repair_names', 'extract_numeric', 'complete_', 'drop_na_', 'expand_', 'crossing_', 'nesting_', 'extract_', 'fill_', 'gather_', 'nest_', 'separate_rows_', 'separate_', 'spread_', 'unite_', 'unnest_', 'extract', 'gather', 'nest_legacy', 'separate_rows', 'separate', 'spread',]

package/linter/rules/file-path-validity.d.ts

@@ -1,8 +1,7 @@
 import type { LintingResult } from '../linter-format';
+import { LintingRuleCertainty } from '../linter-format';
 import type { MergeableRecord } from '../../util/objects';
 import type { SourceRange } from '../../util/range';
-import type { ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { FlowrSearchElementFromQuery } from '../../search/flowr-search';
 import type { FunctionInfo } from '../../queries/catalog/dependencies-query/function-info/function-info';
 import { LintingRuleTag } from '../linter-tags';
 export interface FilePathValidityResult extends LintingResult {
@@ -32,8 +31,8 @@ export interface FilePathValidityMetadata extends MergeableRecord {
     totalValid: number;
 }
 export declare const FILE_PATH_VALIDITY: {
-    readonly createSearch: (config: FilePathValidityConfig) => import("../../search/flowr-search-builder").FlowrSearchBuilder<"from-query", [], ParentInformation, import("../../search/flowr-search").FlowrSearchElements<ParentInformation, FlowrSearchElementFromQuery<ParentInformation>[]>>;
-    readonly processSearchResult: (elements: import("../../search/flowr-search").FlowrSearchElements<ParentInformation, FlowrSearchElementFromQuery<ParentInformation>[]>, config: FilePathValidityConfig, data: {
+    readonly createSearch: (config: FilePathValidityConfig) => import("../../search/flowr-search-builder").FlowrSearchBuilder<"from-query", ["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/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, import("../../search/flowr-search").FlowrSearchElement<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, config: FilePathValidityConfig, data: {
         normalize: import("../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
         dataflow: import("../../dataflow/info").DataflowInformation;
         config: import("../../config").FlowrConfigOptions;
@@ -44,6 +43,7 @@ export declare const FILE_PATH_VALIDITY: {
     readonly info: {
         readonly name: "File Path Validity";
         readonly description: "Checks whether file paths used in read and write operations are valid and point to existing files.";
+        readonly certainty: LintingRuleCertainty.BestEffort;
         readonly tags: readonly [LintingRuleTag.Robustness, LintingRuleTag.Reproducibility, LintingRuleTag.Bug];
         readonly defaultConfig: {
             readonly additionalReadFunctions: readonly [];

package/linter/rules/file-path-validity.js

@@ -10,9 +10,9 @@ const logic_1 = require("../../util/logic");
 const retriever_1 = require("../../r-bridge/retriever");
 const read_functions_1 = require("../../queries/catalog/dependencies-query/function-info/read-functions");
 const write_functions_1 = require("../../queries/catalog/dependencies-query/function-info/write-functions");
-const extract_cfg_1 = require("../../control-flow/extract-cfg");
 const happens_before_1 = require("../../control-flow/happens-before");
 const linter_tags_1 = require("../linter-tags");
+const search_enrichers_1 = require("../../search/search-executor/search-enrichers");
 exports.FILE_PATH_VALIDITY = {
     createSearch: (config) => flowr_search_builder_1.Q.fromQuery({
         type: 'dependencies',
@@ -20,9 +20,9 @@ exports.FILE_PATH_VALIDITY = {
         ignoreDefaultFunctions: true,
         readFunctions: read_functions_1.ReadFunctions.concat(config.additionalReadFunctions),
         writeFunctions: write_functions_1.WriteFunctions.concat(config.additionalWriteFunctions)
-    }),
+    }).with(search_enrichers_1.Enrichment.CfgInformation),
     processSearchResult: (elements, config, data) => {
-        const cfg = (0, extract_cfg_1.extractSimpleCfg)(data.normalize).graph;
+        const cfg = elements.enrichmentContent(search_enrichers_1.Enrichment.CfgInformation).cfg.graph;
         const metadata = {
             totalReads: 0,
             totalUnknown: 0,
@@ -31,7 +31,7 @@ exports.FILE_PATH_VALIDITY = {
         };
         return {
             results: elements.getElements().flatMap(element => {
-                const results = element.queryResult;
+                const results = elements.enrichmentContent(search_enrichers_1.Enrichment.QueryData).queries['dependencies'];
                 const matchingRead = results.readData.find(r => r.nodeId == element.node.info.id);
                 if (!matchingRead) {
                     return [];
@@ -45,7 +45,7 @@ exports.FILE_PATH_VALIDITY = {
                         return [{
                                 range,
                                 filePath: dependencies_query_format_1.Unknown,
-                                certainty: linter_format_1.LintingCertainty.Maybe
+                                certainty: linter_format_1.LintingResultCertainty.Uncertain
                             }];
                     }
                     else {
@@ -70,7 +70,7 @@ exports.FILE_PATH_VALIDITY = {
                 return [{
                         range,
                         filePath: matchingRead.source,
-                        certainty: writesBefore && writesBefore.length && writesBefore.every(w => w === logic_1.Ternary.Maybe) ? linter_format_1.LintingCertainty.Maybe : linter_format_1.LintingCertainty.Definitely
+                        certainty: writesBefore && writesBefore.length && writesBefore.every(w => w === logic_1.Ternary.Maybe) ? linter_format_1.LintingResultCertainty.Uncertain : linter_format_1.LintingResultCertainty.Certain
                     }];
             }),
             '.meta': metadata
@@ -79,6 +79,8 @@ exports.FILE_PATH_VALIDITY = {
     info: {
         name: 'File Path Validity',
         description: 'Checks whether file paths used in read and write operations are valid and point to existing files.',
+        // checks all found paths for whether they're valid to ensure correctness, but doesn't handle non-constant paths so not all will be returned
+        certainty: linter_format_1.LintingRuleCertainty.BestEffort,
         tags: [linter_tags_1.LintingRuleTag.Robustness, linter_tags_1.LintingRuleTag.Reproducibility, linter_tags_1.LintingRuleTag.Bug],
         defaultConfig: {
             additionalReadFunctions: [],

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

@@ -2,8 +2,8 @@ import type { DataflowGraph } from '../../dataflow/graph/graph';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { MergeableRecord } from '../../util/objects';
 import type { SourceRange } from '../../util/range';
-import type { LintQuickFixReplacement, LintingResult } from '../linter-format';
-import { LintingCertainty } from '../linter-format';
+import type { LintingResult, LintQuickFixReplacement } from '../linter-format';
+import { LintingResultCertainty, LintingRuleCertainty } from '../linter-format';
 import { LintingRuleTag } from '../linter-tags';
 export declare enum CasingConvention {
     CamelCase = "camelCase",
@@ -46,7 +46,7 @@ export declare const NAMING_CONVENTION: {
     }) => {
         results: {
             quickFix: LintQuickFixReplacement[] | undefined;
-            certainty: LintingCertainty;
+            certainty: LintingResultCertainty;
             detectedCasing: CasingConvention;
             name: string;
             range: SourceRange;
@@ -62,6 +62,7 @@ export declare const NAMING_CONVENTION: {
     };
     readonly info: {
         readonly name: "Naming Convention";
+        readonly certainty: LintingRuleCertainty.OverApproximative;
         readonly description: "Checks wether the symbols conform to a certain naming convention";
         readonly tags: readonly [LintingRuleTag.Style, LintingRuleTag.QuickFix];
         readonly defaultConfig: {

package/linter/rules/naming-convention.js

@@ -132,7 +132,7 @@ exports.NAMING_CONVENTION = {
     processSearchResult: (elements, config, data) => {
         const symbols = elements.getElements()
             .map(m => ({
-            certainty: linter_format_1.LintingCertainty.Definitely,
+            certainty: linter_format_1.LintingResultCertainty.Certain,
             detectedCasing: detectCasing(m.node.lexeme),
             name: m.node.lexeme,
             range: m.node.info.fullRange,
@@ -158,6 +158,8 @@ exports.NAMING_CONVENTION = {
     },
     info: {
         name: 'Naming Convention',
+        // detects casing heuristically so correctness is not ensured using default config, but checks all identifiers in the code for naming convention match
+        certainty: linter_format_1.LintingRuleCertainty.OverApproximative,
         description: 'Checks wether the symbols conform to a certain naming convention',
         tags: [linter_tags_1.LintingRuleTag.Style, linter_tags_1.LintingRuleTag.QuickFix],
         defaultConfig: {

package/linter/rules/seeded-randomness.d.ts

@@ -1,5 +1,5 @@
 import type { LintingResult } from '../linter-format';
-import { LintingCertainty } from '../linter-format';
+import { LintingResultCertainty, LintingRuleCertainty } from '../linter-format';
 import type { SourceRange } from '../../util/range';
 import type { MergeableRecord } from '../../util/objects';
 import type { Identifier } from '../../dataflow/environments/identifier';
@@ -30,14 +30,14 @@ export interface SeededRandomnessMeta extends MergeableRecord {
     callsWithNonConstantProducers: number;
 }
 export declare const SEEDED_RANDOMNESS: {
-    readonly createSearch: (config: SeededRandomnessConfig) => import("../../search/flowr-search-builder").FlowrSearchBuilder<"all", ["with", "filter", "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 createSearch: (config: SeededRandomnessConfig) => import("../../search/flowr-search-builder").FlowrSearchBuilder<"all", ["with", "filter", "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/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, import("../../search/flowr-search").FlowrSearchElement<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, config: SeededRandomnessConfig, { dataflow }: {
         normalize: import("../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
         dataflow: import("../../dataflow/info").DataflowInformation;
         config: import("../../config").FlowrConfigOptions;
     }) => {
         results: {
-            certainty: LintingCertainty.Definitely;
+            certainty: LintingResultCertainty.Certain;
             function: Identifier;
             range: SourceRange;
         }[];
@@ -55,6 +55,7 @@ export declare const SEEDED_RANDOMNESS: {
             readonly randomnessConsumers: readonly ["jitter", "sample", "sample.int", "arima.sim", "kmeans", "princomp", "rcauchy", "rchisq", "rexp", "rgamma", "rgeom", "rlnorm", "rlogis", "rmultinom", "rnbinom", "rnorm", "rpois", "runif", "pointLabel", "some", "rbernoulli", "rdunif", "generateSeedVectors"];
         };
         readonly tags: readonly [LintingRuleTag.Robustness, LintingRuleTag.Reproducibility];
+        readonly certainty: LintingRuleCertainty.BestEffort;
         readonly name: "Seeded Randomness";
         readonly description: "Checks whether randomness-based function calls are preceded by a random seed generation function. For consistent reproducibility, functions that use randomness should only be called after a constant random seed is set using a function like `set.seed`.";
     };

package/linter/rules/seeded-randomness.js

@@ -86,7 +86,7 @@ exports.SEEDED_RANDOMNESS = {
                 return true;
             })
                 .map(element => ({
-                certainty: linter_format_1.LintingCertainty.Definitely,
+                certainty: linter_format_1.LintingResultCertainty.Certain,
                 function: element.target,
                 range: element.range
             })),
@@ -99,6 +99,8 @@ exports.SEEDED_RANDOMNESS = {
             randomnessConsumers: ['jitter', 'sample', 'sample.int', 'arima.sim', 'kmeans', 'princomp', 'rcauchy', 'rchisq', 'rexp', 'rgamma', 'rgeom', 'rlnorm', 'rlogis', 'rmultinom', 'rnbinom', 'rnorm', 'rpois', 'runif', 'pointLabel', 'some', 'rbernoulli', 'rdunif', 'generateSeedVectors'],
         },
         tags: [linter_tags_1.LintingRuleTag.Robustness, linter_tags_1.LintingRuleTag.Reproducibility],
+        // only finds proper randomness producers and consumers due to its config, but will not find all producers/consumers since not all existing deprecated functions will be in the config
+        certainty: linter_format_1.LintingRuleCertainty.BestEffort,
         name: 'Seeded Randomness',
         description: 'Checks whether randomness-based function calls are preceded by a random seed generation function. For consistent reproducibility, functions that use randomness should only be called after a constant random seed is set using a function like `set.seed`.'
     },

package/linter/rules/unused-definition.d.ts

@@ -1,4 +1,5 @@
 import type { LintingResult } from '../linter-format';
+import { LintingRuleCertainty } from '../linter-format';
 import type { MergeableRecord } from '../../util/objects';
 import type { SourceRange } from '../../util/range';
 import { LintingRuleTag } from '../linter-tags';
@@ -34,6 +35,7 @@ export declare const UNUSED_DEFINITION: {
         readonly name: "Unused Definitions";
         readonly description: "Checks for unused definitions.";
         readonly tags: readonly [LintingRuleTag.Readability, LintingRuleTag.Smell, LintingRuleTag.QuickFix];
+        readonly certainty: LintingRuleCertainty.BestEffort;
         readonly defaultConfig: {
             readonly includeFunctionDefinitions: true;
         };

package/linter/rules/unused-definition.js

@@ -80,7 +80,7 @@ exports.UNUSED_DEFINITION = {
                 // found an unused definition
                 const variableName = element.node.lexeme;
                 return [{
-                        certainty: linter_format_1.LintingCertainty.Maybe,
+                        certainty: linter_format_1.LintingResultCertainty.Uncertain,
                         variableName,
                         range: element.node.info.fullRange ?? element.node.location ?? (0, range_1.rangeFrom)(-1, -1, -1, -1),
                         quickFix: buildQuickFix(element.node, data.dataflow.graph, data.normalize)
@@ -97,6 +97,8 @@ exports.UNUSED_DEFINITION = {
         name: 'Unused Definitions',
         description: 'Checks for unused definitions.',
         tags: [linter_tags_1.LintingRuleTag.Readability, linter_tags_1.LintingRuleTag.Smell, linter_tags_1.LintingRuleTag.QuickFix],
+        // our limited analysis causes unused definitions involving complex reflection etc. not to be included in our result, but unused definitions are correctly validated
+        certainty: linter_format_1.LintingRuleCertainty.BestEffort,
         defaultConfig: {
             includeFunctionDefinitions: true
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/flowr",
-  "version": "2.3.0",
+  "version": "2.4.1",
   "description": "Static Dataflow Analyzer and Program Slicer for the R Programming Language",
   "types": "dist/src/index.d.ts",
   "repository": {

package/queries/base-query-format.d.ts

@@ -1,6 +1,7 @@
 import type { NormalizedAst } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { DataflowInformation } from '../dataflow/info';
 import type { FlowrConfigOptions } from '../config';
+import type { SemVer } from 'semver';
 export interface BaseQueryFormat {
     /** used to select the query type :) */
     readonly type: string;
@@ -13,6 +14,7 @@ export interface BaseQueryResult {
     readonly '.meta': BaseQueryMeta;
 }
 export interface BasicQueryData {
+    readonly lib?: Record<string, SemVer>;
     readonly ast: NormalizedAst;
     readonly dataflow: DataflowInformation;
     readonly config: FlowrConfigOptions;

package/queries/catalog/call-context-query/identify-link-to-last-call-relation.js

@@ -41,13 +41,7 @@ function satisfiesCallTargets(id, graph, callTarget) {
         .filter(([, { types }]) => (0, edge_1.edgeIncludesType)(types, edge_1.EdgeType.Calls))
         .map(([t]) => t);
     let builtIn = false;
-    if (callVertex.environment === undefined) {
-        /* if we have a call with an unbound environment,
-         * this only happens if we are sure of built-in relations and want to save references
-         */
-        builtIn = true;
-    }
-    else {
+    if (callVertex.environment !== undefined) {
         /*
          * for performance and scoping reasons, flowR will not identify the global linkage,
          * including any potential built-in mapping.
@@ -57,6 +51,12 @@ function satisfiesCallTargets(id, graph, callTarget) {
             builtIn = true;
         }
     }
+    else {
+        /* if we have a call with an unbound environment,
+         * this only happens if we are sure of built-in relations and want to save references
+         */
+        builtIn = true;
+    }
     switch (callTarget) {
         case CallTargets.Any:
             return callTargets;

package/queries/catalog/dependencies-query/dependencies-query-executor.js

@@ -15,6 +15,7 @@ const write_functions_1 = require("./function-info/write-functions");
 const function_info_1 = require("./function-info/function-info");
 const identify_link_to_last_call_relation_1 = require("../call-context-query/identify-link-to-last-call-relation");
 const resolve_argument_1 = require("../../../dataflow/eval/resolve/resolve-argument");
+const assert_1 = require("../../../util/assert");
 function collectNamespaceAccesses(data, libraries) {
     /* for libraries, we have to additionally track all uses of `::` and `:::`, for this we currently simply traverse all uses */
     (0, visitor_1.visitAst)(data.ast.ast, n => {
@@ -40,7 +41,12 @@ function executeDependenciesQuery(data, queries) {
     const readFunctions = getFunctionsToCheck(query.readFunctions, ignoreDefault, read_functions_1.ReadFunctions);
     const writeFunctions = getFunctionsToCheck(query.writeFunctions, ignoreDefault, write_functions_1.WriteFunctions);
     const numberOfFunctions = libraryFunctions.length + sourceFunctions.length + readFunctions.length + writeFunctions.length;
-    const results = numberOfFunctions === 0 ? { kinds: {}, '.meta': { timing: 0 } } : (0, query_1.executeQueriesOfSameType)(data, ...makeCallContextQuery(libraryFunctions, 'library'), ...makeCallContextQuery(sourceFunctions, 'source'), ...makeCallContextQuery(readFunctions, 'read'), ...makeCallContextQuery(writeFunctions, 'write'));
+    const results = numberOfFunctions === 0 ? { kinds: {}, '.meta': { timing: 0 } } : (0, query_1.executeQueriesOfSameType)(data, [
+        makeCallContextQuery(libraryFunctions, 'library'),
+        makeCallContextQuery(sourceFunctions, 'source'),
+        makeCallContextQuery(readFunctions, 'read'),
+        makeCallContextQuery(writeFunctions, 'write')
+    ].flat());
     function getLexeme(argument, id) {
         if ((argument && argument !== dependencies_query_format_1.Unknown) || !id) {
             return undefined;
@@ -108,6 +114,8 @@ function dropInfoOnLinkedIds(linkedIds) {
     }
     return linkedIds.map(id => typeof id === 'object' ? id.id : id);
 }
+const readOnlyModes = new Set(['r', 'rt', 'rb']);
+const writeOnlyModes = new Set(['w', 'wt', 'wb', 'a', 'at', 'ab']);
 function getResults(data, results, kind, functions, makeInfo) {
     const kindEntries = Object.entries(results?.kinds[kind]?.subkinds ?? {});
     return kindEntries.flatMap(([name, results]) => results.flatMap(({ id, linkedIds }) => {
@@ -123,6 +131,21 @@ function getResults(data, results, kind, functions, makeInfo) {
             const record = (0, objects_1.compactRecord)(makeInfo(id, vertex, undefined, undefined, dropInfoOnLinkedIds(linkedIds)));
             return record ? [record] : [];
         }
+        else if (info.ignoreIf === 'mode-only-read' || info.ignoreIf === 'mode-only-write') {
+            (0, assert_1.guard)('mode' in (info.additionalArgs ?? {}), 'Need additional argument mode when checking for mode');
+            const margs = info.additionalArgs?.mode;
+            (0, assert_1.guard)(margs, 'Need additional argument mode when checking for mode');
+            const modeArgs = (0, resolve_argument_1.getArgumentStringValue)(data.config.solver.variables, data.dataflow.graph, vertex, margs.argIdx, margs.argName, margs.resolveValue);
+            const modeValues = modeArgs?.values().flatMap(v => [...v]) ?? [];
+            if (info.ignoreIf === 'mode-only-read' && modeValues.every(m => m && readOnlyModes.has(m))) {
+                // all modes are read-only, so we can ignore this
+                return [];
+            }
+            else if (info.ignoreIf === 'mode-only-write' && modeValues.every(m => m && writeOnlyModes.has(m))) {
+                // all modes are write-only, so we can ignore this
+                return [];
+            }
+        }
         const results = [];
         for (const [arg, values] of foundValues.entries()) {
             for (const value of values) {

package/queries/catalog/dependencies-query/function-info/function-info.d.ts

@@ -12,13 +12,17 @@ export type DependencyInfoLink = LinkTo<RegExp | string, Omit<FunctionInfo, 'nam
     when: DependencyInfoLinkConstraint;
 } | undefined>;
 export type DependencyInfoLinkAttachedInfo = DependencyInfoLink['attachLinkInfo'];
-export interface FunctionInfo {
-    package?: string;
-    name: string;
+export interface FunctionArgInfo {
     /** the index if the argument can be positional, unnamed in case of something like `...`, if the argument must be given with the name, please leave undefined */
     argIdx?: number | 'unnamed';
     argName?: string;
-    linkTo?: DependencyInfoLink[];
     resolveValue?: boolean | 'library';
-    ignoreIf?: 'arg-missing';
+}
+export interface FunctionInfo extends FunctionArgInfo {
+    package?: string;
+    name: string;
+    linkTo?: DependencyInfoLink[];
+    ignoreIf?: 'arg-missing' | 'mode-only-read' | 'mode-only-write';
+    /** additional info on arguments - e.g. for the mode flag */
+    additionalArgs?: Record<string, FunctionArgInfo>;
 }

package/queries/catalog/dependencies-query/function-info/read-functions.js

@@ -10,8 +10,8 @@ exports.ReadFunctions = [
     { package: 'base', name: 'read.dcf', argIdx: 0, argName: 'file', resolveValue: true },
     { package: 'base', name: 'scan', argIdx: 0, argName: 'file', resolveValue: true },
     { package: 'utils', name: 'read.fwf', argIdx: 0, argName: 'file', resolveValue: true },
-    { package: 'base', name: 'file', argIdx: 1, argName: 'open', resolveValue: true },
-    { package: 'base', name: 'url', argIdx: 1, argName: 'open', resolveValue: true },
+    { package: 'base', name: 'file', argIdx: 0, argName: 'description', resolveValue: true, ignoreIf: 'mode-only-write', additionalArgs: { mode: { argIdx: 1, argName: 'open', resolveValue: true } } },
+    { package: 'base', name: 'url', argIdx: 0, argName: 'description', resolveValue: true, ignoreIf: 'mode-only-write', additionalArgs: { mode: { argIdx: 1, argName: 'open', resolveValue: true } } },
     { package: 'base', name: 'load', argIdx: 0, argName: 'file', resolveValue: true },
     { package: 'base', name: 'gzfile', argIdx: 1, argName: 'open', resolveValue: true },
     { package: 'base', name: 'bzfile', argIdx: 1, argName: 'open', resolveValue: true },
@@ -22,6 +22,8 @@ exports.ReadFunctions = [
     { package: 'base', name: 'matrix', argIdx: 0, argName: 'data', resolveValue: true },
     { package: 'base', name: 'readRDS', argIdx: 0, argName: 'file', resolveValue: true },
     { package: 'base', name: 'readLines', argIdx: 0, argName: 'con', resolveValue: true },
+    { package: 'base', name: 'readChar', argIdx: 0, argName: 'con', resolveValue: true },
+    { package: 'base', name: 'readBin', argIdx: 0, argName: 'con', resolveValue: true },
     { package: 'base', name: 'readRenviron', argIdx: 0, argName: 'path', resolveValue: true },
     { package: 'readr', name: 'read_csv', argIdx: 0, argName: 'file', resolveValue: true },
     { package: 'readr', name: 'read_csv2', argIdx: 0, argName: 'file', resolveValue: true },
@@ -97,5 +99,6 @@ exports.ReadFunctions = [
     { package: 'stats', name: 'read.ftable', argIdx: 0, argName: 'file', resolveValue: true },
     { package: 'DBI', name: 'dbReadTable', argIdx: 1, argName: 'name', resolveValue: true },
     { package: 'DBI', name: 'dbReadTableArrow', argIdx: 1, argName: 'name', resolveValue: true },
+    { package: 'jsonlite', name: 'read_json', argIdx: 0, argName: 'path', resolveValue: true },
 ];
 //# sourceMappingURL=read-functions.js.map

package/queries/catalog/dependencies-query/function-info/write-functions.js

@@ -19,6 +19,11 @@ exports.WriteFunctions = [
     { package: 'base', name: 'cat', linkTo: OutputRedirects, argName: 'file', resolveValue: true },
     { package: 'base', name: 'message', linkTo: OutputRedirects, resolveValue: true },
     { package: 'base', name: 'warning', linkTo: OutputRedirects, resolveValue: true },
+    { package: 'base', name: 'writeLines', argIdx: 1, argName: 'con', resolveValue: true },
+    { package: 'base', name: 'writeChar', argIdx: 1, argName: 'con', resolveValue: true },
+    { package: 'base', name: 'writeBin', argIdx: 1, argName: 'con', resolveValue: true },
+    { package: 'base', name: 'file', argIdx: 0, argName: 'description', resolveValue: true, ignoreIf: 'mode-only-read', additionalArgs: { mode: { argIdx: 1, argName: 'open', resolveValue: true } } },
+    { package: 'base', name: 'url', argIdx: 0, argName: 'description', resolveValue: true, ignoreIf: 'mode-only-read', additionalArgs: { mode: { argIdx: 1, argName: 'open', resolveValue: true } } },
     { package: 'readr', name: 'write_csv', argIdx: 1, argName: 'file', resolveValue: true },
     { package: 'readr', name: 'write_csv2', argIdx: 1, argName: 'file', resolveValue: true },
     { package: 'readr', name: 'write_delim', argIdx: 1, argName: 'file', resolveValue: true },
@@ -83,5 +88,6 @@ exports.WriteFunctions = [
     { package: 'rasterpdf', name: 'raster_pdf', argIdx: 0, argName: 'filename', resolveValue: true },
     { package: 'rasterpdf', name: 'agg_pdf', argIdx: 0, argName: 'filename', resolveValue: true },
     { package: 'highcharter', name: 'hc_exporting', argName: 'filename', resolveValue: true },
+    { package: 'jsonlite', name: 'write_json', argIdx: 1, argName: 'path', resolveValue: true },
 ];
 //# sourceMappingURL=write-functions.js.map

package/queries/catalog/linter-query/linter-query-format.js

@@ -33,7 +33,7 @@ exports.LinterQueryDefinition = {
 function addLintingRuleResult(ruleName, results, result) {
     const rule = linter_rules_1.LintingRules[ruleName];
     result.push(`   ╰ **${rule.info.name}** (${ruleName}):`);
-    for (const certainty of [linter_format_1.LintingCertainty.Definitely, linter_format_1.LintingCertainty.Maybe]) {
+    for (const certainty of [linter_format_1.LintingResultCertainty.Certain, linter_format_1.LintingResultCertainty.Uncertain]) {
         const certaintyResults = results.results.filter(r => r.certainty === certainty);
         if (certaintyResults.length) {
             result.push(`       ╰ ${certainty}:`);