@eagleoutice/flowr 2.2.15 → 2.3.0

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

@@ -0,0 +1,71 @@
+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 { LintingRuleTag } from '../linter-tags';
+export declare enum CasingConvention {
+    CamelCase = "camelCase",
+    PascalCase = "PascalCase",
+    SnakeCase = "snake_case",
+    ConstantCase = "CONSTANT_CASE",
+    CamelSnakeCase = "camel_Snake_Case",
+    PascalSnakeCase = "Pascal_Snake_Case",
+    Unknown = "unknown"
+}
+export interface NamingConventionResult extends LintingResult {
+    name: string;
+    detectedCasing: CasingConvention;
+    range: SourceRange;
+}
+/**
+ * It is planned to have a config like ESLint
+ */
+export interface NamingConventionConfig extends MergeableRecord {
+    caseing: CasingConvention | 'auto';
+}
+export interface NamingConventionMetadata extends MergeableRecord {
+    /** number of symbols matching the casing convetion */
+    numMatches: number;
+    /** number of symbols breaking the casing convetion */
+    numBreak: number;
+}
+export declare function detectCasing(identifier: string): CasingConvention;
+export declare function getMostUsedCasing(symbols: {
+    detectedCasing: CasingConvention;
+}[]): CasingConvention;
+export declare function fixCasing(identifier: string, convention: CasingConvention): string;
+export declare function createNamingConventionQuickFixes(graph: DataflowGraph, nodeId: NodeId, replacement: string, conv: CasingConvention): LintQuickFixReplacement[] | undefined;
+export declare const NAMING_CONVENTION: {
+    readonly createSearch: (_config: NamingConventionConfig) => import("../../search/flowr-search-builder").FlowrSearchBuilder<"all", ["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>[]>, config: NamingConventionConfig, data: {
+        normalize: import("../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+        dataflow: import("../../dataflow/info").DataflowInformation;
+        config: import("../../config").FlowrConfigOptions;
+    }) => {
+        results: {
+            quickFix: LintQuickFixReplacement[] | undefined;
+            certainty: LintingCertainty;
+            detectedCasing: CasingConvention;
+            name: string;
+            range: SourceRange;
+        }[];
+        '.meta': {
+            numMatches: number;
+            numBreak: number;
+        };
+    };
+    readonly prettyPrint: {
+        readonly query: (result: NamingConventionResult) => string;
+        readonly full: (result: NamingConventionResult) => string;
+    };
+    readonly info: {
+        readonly name: "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: "auto";
+        };
+    };
+};

package/linter/rules/naming-convention.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NAMING_CONVENTION = exports.CasingConvention = void 0;
+exports.detectCasing = detectCasing;
+exports.getMostUsedCasing = getMostUsedCasing;
+exports.fixCasing = fixCasing;
+exports.createNamingConventionQuickFixes = createNamingConventionQuickFixes;
+const vertex_1 = require("../../dataflow/graph/vertex");
+const dfg_get_symbol_refs_1 = require("../../dataflow/origin/dfg-get-symbol-refs");
+const flowr_search_builder_1 = require("../../search/flowr-search-builder");
+const assert_1 = require("../../util/assert");
+const dfg_1 = require("../../util/mermaid/dfg");
+const linter_format_1 = require("../linter-format");
+const linter_tags_1 = require("../linter-tags");
+var CasingConvention;
+(function (CasingConvention) {
+    CasingConvention["CamelCase"] = "camelCase";
+    CasingConvention["PascalCase"] = "PascalCase";
+    CasingConvention["SnakeCase"] = "snake_case";
+    CasingConvention["ConstantCase"] = "CONSTANT_CASE";
+    CasingConvention["CamelSnakeCase"] = "camel_Snake_Case";
+    CasingConvention["PascalSnakeCase"] = "Pascal_Snake_Case";
+    CasingConvention["Unknown"] = "unknown";
+})(CasingConvention || (exports.CasingConvention = CasingConvention = {}));
+function detectCasing(identifier) {
+    if (identifier.trim() === '') {
+        return CasingConvention.Unknown;
+    }
+    const upper = identifier.toUpperCase();
+    const lower = identifier.toLowerCase();
+    const isAllUpper = identifier === upper;
+    const isAllLower = identifier === lower;
+    if (identifier.includes('_')) {
+        if (isAllUpper) { // CONSTANT_CASE
+            return CasingConvention.ConstantCase;
+        }
+        else if (isAllLower) { // snake_case
+            return CasingConvention.SnakeCase;
+        }
+        // Returns true if the letter after an _ is uppercase
+        function expectUpperAfterScore(identifier) {
+            for (let i = 0; i < identifier.length - 1; i++) {
+                if (identifier[i] === '_') {
+                    if (identifier[i + 1] !== upper[i + 1]) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+        if (identifier[0] === lower[0] && expectUpperAfterScore(identifier)) { // camel_Snake_Case
+            return CasingConvention.CamelSnakeCase;
+        }
+        else if (identifier[0] === upper[0] && expectUpperAfterScore(identifier)) { // Pascal_Snake_Case
+            return CasingConvention.PascalSnakeCase;
+        }
+    }
+    else {
+        if (identifier[0] === lower[0]) { // camelCase
+            return CasingConvention.CamelCase;
+        }
+        else if (identifier[0] === upper[0]) { // PascalCase
+            return CasingConvention.PascalCase;
+        }
+    }
+    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) {
+    const tokens = identifier.split(/(?=[A-Z])|_/).map(s => s.toLowerCase());
+    const firstUp = (s) => `${s[0].toUpperCase()}${s.substring(1)}`;
+    switch (convention) {
+        case CasingConvention.CamelCase: // camelCase
+            return `${tokens[0]}${tokens.slice(1).map(firstUp).join('')}`;
+        case CasingConvention.PascalCase: // PascalCase
+            return tokens.map(firstUp).join('');
+        case CasingConvention.SnakeCase: // snake_case
+            return tokens.join('_');
+        case CasingConvention.ConstantCase: // CONSTANT_CASE
+            return tokens.map(s => s.toUpperCase()).join('_');
+        case CasingConvention.CamelSnakeCase: // camel_Snake_Case
+            return `${tokens[0]}_${tokens.slice(1).map(firstUp).join('_')}`;
+        case CasingConvention.PascalSnakeCase: // Pascal_Snake_Case
+            return tokens.map(firstUp).join('_');
+        case CasingConvention.Unknown:
+            return identifier;
+        default:
+            (0, assert_1.assertUnreachable)(convention);
+    }
+}
+function createNamingConventionQuickFixes(graph, nodeId, replacement, conv) {
+    const refs = (0, dfg_get_symbol_refs_1.getAllRefsToSymbol)(graph, nodeId);
+    const idMap = graph.idMap;
+    if (refs === undefined || idMap === undefined) {
+        return undefined;
+    }
+    const result = [];
+    for (const ref of refs) {
+        const node = idMap.get(ref);
+        if (node === undefined) {
+            continue;
+        }
+        const range = node.info.fullRange;
+        if (range) {
+            // In case of a function call we only need to include the name, not the '()'
+            range[3] = range[1] + node.lexeme.length - 1;
+            result.push({
+                type: 'replace',
+                replacement: replacement,
+                description: `Rename to match naming convention ${conv}`,
+                range: range
+            });
+        }
+    }
+    return result.length === 0 ?
+        undefined : // We sort so that when applied in order the fixes will start from the end of the line to avoid conflicts
+        result.sort((a, b) => a.range[0] == b.range[0] ? b.range[1] - a.range[1] : b.range[0] - a.range[0]);
+}
+exports.NAMING_CONVENTION = {
+    createSearch: (_config) => flowr_search_builder_1.Q.all().filter(vertex_1.VertexType.VariableDefinition),
+    processSearchResult: (elements, config, data) => {
+        const symbols = elements.getElements()
+            .map(m => ({
+            certainty: linter_format_1.LintingCertainty.Definitely,
+            detectedCasing: detectCasing(m.node.lexeme),
+            name: m.node.lexeme,
+            range: m.node.info.fullRange,
+            id: m.node.info.id
+        }));
+        const casing = config.caseing === 'auto' ? getMostUsedCasing(symbols) : config.caseing;
+        const results = symbols.filter(m => m.detectedCasing !== casing)
+            .map(({ id, ...m }) => ({
+            ...m,
+            quickFix: createNamingConventionQuickFixes(data.dataflow.graph, id, fixCasing(m.name, casing), casing)
+        }));
+        return {
+            results: results,
+            '.meta': {
+                numMatches: symbols.length - results.length,
+                numBreak: results.length
+            }
+        };
+    },
+    prettyPrint: {
+        [linter_format_1.LintingPrettyPrintContext.Query]: result => `Identifier '${result.name}' at ${(0, dfg_1.formatRange)(result.range)} (${result.detectedCasing})`,
+        [linter_format_1.LintingPrettyPrintContext.Full]: result => `Identifier '${result.name}' at ${(0, dfg_1.formatRange)(result.range)} follows wrong convention: ${result.detectedCasing}`
+    },
+    info: {
+        name: '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: 'auto'
+        }
+    }
+};
+//# sourceMappingURL=naming-convention.js.map

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

@@ -0,0 +1,65 @@
+import type { LintingResult } from '../linter-format';
+import { LintingCertainty } from '../linter-format';
+import type { SourceRange } from '../../util/range';
+import type { MergeableRecord } from '../../util/objects';
+import type { Identifier } from '../../dataflow/environments/identifier';
+import { LintingRuleTag } from '../linter-tags';
+export interface SeededRandomnessResult extends LintingResult {
+    function: string;
+    range: SourceRange;
+}
+export interface SeededRandomnessConfig extends MergeableRecord {
+    /**
+     * A set of functions and variables whose invocation or assignment causes a random seeded to be set.
+     * Each entry has a `type`, which is either `function` or `assignment`, and a `name`, which is the name of the function or variable.
+     * The default value for this is the function `set.seed` and the variable `.Random.seed`.
+     */
+    randomnessProducers: {
+        type: 'function' | 'assignment';
+        name: string;
+    }[];
+    /**
+     * A set of randomness consumer function names that require a seed to be set prior to invocation.
+     */
+    randomnessConsumers: string[];
+}
+export interface SeededRandomnessMeta extends MergeableRecord {
+    consumerCalls: number;
+    callsWithFunctionProducers: number;
+    callsWithAssignmentProducers: number;
+    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 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;
+            function: Identifier;
+            range: SourceRange;
+        }[];
+        '.meta': SeededRandomnessMeta;
+    };
+    readonly info: {
+        readonly defaultConfig: {
+            readonly randomnessProducers: readonly [{
+                readonly type: "function";
+                readonly name: "set.seed";
+            }, {
+                readonly type: "assignment";
+                readonly name: ".Random.seed";
+            }];
+            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 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`.";
+    };
+    readonly prettyPrint: {
+        readonly query: (result: SeededRandomnessResult, _meta: SeededRandomnessMeta) => string;
+        readonly full: (result: SeededRandomnessResult, _meta: SeededRandomnessMeta) => string;
+    };
+};

package/linter/rules/seeded-randomness.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEEDED_RANDOMNESS = void 0;
+const linter_format_1 = require("../linter-format");
+const flowr_search_builder_1 = require("../../search/flowr-search-builder");
+const dfg_1 = require("../../util/mermaid/dfg");
+const search_enrichers_1 = require("../../search/search-executor/search-enrichers");
+const flowr_search_filters_1 = require("../../search/flowr-search-filters");
+const default_builtin_config_1 = require("../../dataflow/environments/default-builtin-config");
+const graph_1 = require("../../dataflow/graph/graph");
+const cascade_action_1 = require("../../queries/catalog/call-context-query/cascade-action");
+const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
+const linter_tags_1 = require("../linter-tags");
+const alias_tracking_1 = require("../../dataflow/eval/resolve/alias-tracking");
+const general_1 = require("../../dataflow/eval/values/general");
+const config_1 = require("../../config");
+const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const r_value_1 = require("../../dataflow/eval/values/r-value");
+exports.SEEDED_RANDOMNESS = {
+    createSearch: (config) => flowr_search_builder_1.Q.all()
+        .with(search_enrichers_1.Enrichment.CallTargets, { onlyBuiltin: true })
+        .filter({
+        name: flowr_search_filters_1.FlowrFilter.MatchesEnrichment,
+        args: {
+            enrichment: search_enrichers_1.Enrichment.CallTargets,
+            test: (0, flowr_search_filters_1.testFunctionsIgnoringPackage)(config.randomnessConsumers)
+        }
+    })
+        .with(search_enrichers_1.Enrichment.LastCall, [
+        ...config.randomnessProducers.filter(p => p.type === 'function').map(p => ({ callName: p.name })),
+        ...getDefaultAssignments().flatMap(b => b.names).map(a => ({ callName: a, cascadeIf: () => cascade_action_1.CascadeAction.Continue }))
+    ]),
+    processSearchResult: (elements, config, { dataflow }) => {
+        const assignmentProducers = new Set(config.randomnessProducers.filter(p => p.type == 'assignment').map(p => p.name));
+        const assignmentArgIndexes = new Map(getDefaultAssignments().flatMap(a => a.names.map(n => ([n, a.config?.swapSourceAndTarget ? 1 : 0]))));
+        const metadata = {
+            consumerCalls: 0,
+            callsWithFunctionProducers: 0,
+            callsWithAssignmentProducers: 0,
+            callsWithNonConstantProducers: 0
+        };
+        return {
+            results: elements.getElements()
+                // map and filter consumers
+                .flatMap(element => (0, search_enrichers_1.enrichmentContent)(element, search_enrichers_1.Enrichment.CallTargets).targets.map(target => {
+                metadata.consumerCalls++;
+                return {
+                    range: element.node.info.fullRange,
+                    target: target,
+                    searchElement: element
+                };
+            }))
+                // filter by calls that aren't preceded by a randomness producer
+                .filter(element => {
+                const producers = (0, search_enrichers_1.enrichmentContent)(element.searchElement, search_enrichers_1.Enrichment.LastCall).linkedIds
+                    .map(e => dataflow.graph.getVertex(e.node.info.id));
+                const { assignment, func } = Object.groupBy(producers, f => assignmentArgIndexes.has(f.name) ? 'assignment' : 'func');
+                let nonConstant = false;
+                // function calls are already taken care of through the LastCall enrichment itself
+                for (const f of func ?? []) {
+                    if (isConstantArgument(dataflow.graph, f, 0)) {
+                        metadata.callsWithFunctionProducers++;
+                        return false;
+                    }
+                    else {
+                        nonConstant = true;
+                    }
+                }
+                // assignments have to be queried for their destination
+                for (const a of assignment ?? []) {
+                    const argIdx = assignmentArgIndexes.get(a.name);
+                    const dest = (0, graph_1.getReferenceOfArgument)(a.args[argIdx]);
+                    if (dest !== undefined && assignmentProducers.has((0, node_id_1.recoverName)(dest, dataflow.graph.idMap))) {
+                        if (isConstantArgument(dataflow.graph, a, 1 - argIdx)) {
+                            metadata.callsWithAssignmentProducers++;
+                            return false;
+                        }
+                        else {
+                            nonConstant = true;
+                        }
+                    }
+                }
+                if (nonConstant) {
+                    metadata.callsWithNonConstantProducers++;
+                }
+                return true;
+            })
+                .map(element => ({
+                certainty: linter_format_1.LintingCertainty.Definitely,
+                function: element.target,
+                range: element.range
+            })),
+            '.meta': metadata
+        };
+    },
+    info: {
+        defaultConfig: {
+            randomnessProducers: [{ type: 'function', name: 'set.seed' }, { type: 'assignment', name: '.Random.seed' }],
+            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],
+        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`.'
+    },
+    prettyPrint: {
+        [linter_format_1.LintingPrettyPrintContext.Query]: (result, _meta) => `Function \`${result.function}\` at ${(0, dfg_1.formatRange)(result.range)}`,
+        [linter_format_1.LintingPrettyPrintContext.Full]: (result, _meta) => `Function \`${result.function}\` at ${(0, dfg_1.formatRange)(result.range)} is called without a preceding random seed function like \`set.seed\``
+    }
+};
+function getDefaultAssignments() {
+    return default_builtin_config_1.DefaultBuiltinConfig.filter(b => b.type === 'function' && b.processor == 'builtin:assignment');
+}
+function isConstantArgument(graph, call, argIndex) {
+    const args = call.args.filter(arg => arg !== r_function_call_1.EmptyArgument && !arg.name).map(graph_1.getReferenceOfArgument);
+    const values = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(args[argIndex], { graph: graph, resolve: config_1.VariableResolve.Alias }));
+    return values?.elements.every(v => v.type === 'number' ||
+        v.type === 'logical' ||
+        v.type === 'string' ||
+        v.type === 'interval' && v.startInclusive && v.endInclusive && v.start.type === 'number' && v.end.type === 'number' && (0, r_value_1.asValue)(v.start.value).num === (0, r_value_1.asValue)(v.end.value).num)
+        ?? false;
+}
+//# sourceMappingURL=seeded-randomness.js.map

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

@@ -0,0 +1,41 @@
+import type { LintingResult } from '../linter-format';
+import type { MergeableRecord } from '../../util/objects';
+import type { SourceRange } from '../../util/range';
+import { LintingRuleTag } from '../linter-tags';
+import type { NormalizedAst, ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
+export interface UnusedDefinitionResult extends LintingResult {
+    variableName?: string;
+    range: SourceRange;
+}
+export interface UnusedDefinitionConfig extends MergeableRecord {
+    /**
+     * Whether to include (potentially anonymous) function definitions in the search (e.g., should we report uncalled anonymous functions?).
+     */
+    includeFunctionDefinitions: boolean;
+}
+export interface UnusedDefinitionMetadata extends MergeableRecord {
+    totalConsidered: number;
+}
+export declare const UNUSED_DEFINITION: {
+    readonly createSearch: (config: UnusedDefinitionConfig) => import("../../search/flowr-search-builder").FlowrSearchBuilder<"all", ["filter"], ParentInformation, import("../../search/flowr-search").FlowrSearchElements<ParentInformation, [] | import("../../search/flowr-search").FlowrSearchElement<ParentInformation>[]>>;
+    readonly processSearchResult: (elements: import("../../search/flowr-search").FlowrSearchElements<ParentInformation, import("../../search/flowr-search").FlowrSearchElement<ParentInformation>[]>, config: UnusedDefinitionConfig, data: {
+        normalize: NormalizedAst;
+        dataflow: import("../../dataflow/info").DataflowInformation;
+        config: import("../../config").FlowrConfigOptions;
+    }) => {
+        results: UnusedDefinitionResult[];
+        ".meta": UnusedDefinitionMetadata;
+    };
+    readonly prettyPrint: {
+        readonly query: (result: UnusedDefinitionResult) => string;
+        readonly full: (result: UnusedDefinitionResult) => string;
+    };
+    readonly info: {
+        readonly name: "Unused Definitions";
+        readonly description: "Checks for unused definitions.";
+        readonly tags: readonly [LintingRuleTag.Readability, LintingRuleTag.Smell, LintingRuleTag.QuickFix];
+        readonly defaultConfig: {
+            readonly includeFunctionDefinitions: true;
+        };
+    };
+};

package/linter/rules/unused-definition.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNUSED_DEFINITION = void 0;
+const linter_format_1 = require("../linter-format");
+const flowr_search_builder_1 = require("../../search/flowr-search-builder");
+const range_1 = require("../../util/range");
+const dfg_1 = require("../../util/mermaid/dfg");
+const linter_tags_1 = require("../linter-tags");
+const assert_1 = require("../../util/assert");
+const vertex_1 = require("../../dataflow/graph/vertex");
+const edge_1 = require("../../dataflow/graph/edge");
+const flowr_search_filters_1 = require("../../search/flowr-search-filters");
+const InterestingEdgesVariable = edge_1.EdgeType.Reads | edge_1.EdgeType.Calls | edge_1.EdgeType.DefinesOnCall;
+const InterestingEdgesFunction = edge_1.EdgeType.Reads | edge_1.EdgeType.Calls; // include read as this could print the function definition
+const InterestingEdgesTargets = edge_1.EdgeType.SideEffectOnCall;
+function getDefinitionArguments(def, dfg) {
+    return [...dfg.outgoingEdges(def) ?? []].filter(([, { types }]) => (0, edge_1.edgeIncludesType)(types, edge_1.EdgeType.DefinedBy))
+        .map(([target]) => target);
+}
+function buildQuickFix(variable, dfg, ast) {
+    // first we check whether any of the 'Defined by' targets have any obligations - if so, we can not remove the definition
+    // otherwise we can automatically remove the full definition!
+    if (variable.info.role === "accessed" /* RoleInParent.Accessed */ || variable.info.role === "for-variable" /* RoleInParent.ForVariable */) {
+        // this is an access or a for variable, we can not remove it currently
+        return undefined;
+    }
+    const definedBys = getDefinitionArguments(variable.info.id, dfg);
+    const hasImportantArgs = definedBys.some(d => dfg.unknownSideEffects.has(d))
+        || definedBys.flatMap(e => [...dfg.outgoingEdges(e) ?? []])
+            .some(([target, { types }]) => {
+            return (0, edge_1.edgeIncludesType)(types, InterestingEdgesTargets) || dfg.unknownSideEffects.has(target);
+        });
+    if (hasImportantArgs) {
+        return undefined; // we can not remove this definition, it has important arguments
+    }
+    const totalRangeToRemove = (0, range_1.mergeRanges)(...definedBys.map(d => {
+        const vertex = ast.idMap.get(d);
+        return vertex?.info.fullRange ?? vertex?.location;
+    }), variable.info.fullRange ?? variable.location);
+    return [{
+            type: 'remove',
+            range: totalRangeToRemove,
+            description: `Remove unused definition of \`${variable.lexeme}\``
+        }];
+}
+/**
+ * consider `x <- function() ...` if we say `x` is unused and propose to remove everything, there should be no separate quick fix for the function definition
+ */
+function onlyKeepSupersetOfUnused(elements) {
+    const ranges = elements.flatMap(e => e.quickFix?.map(q => q.range) ?? [e.range]);
+    if (ranges.length <= 1) {
+        return elements; // nothing to filter, only one element
+    }
+    return elements.filter(e => {
+        const otherRange = (0, range_1.mergeRanges)(...(e.quickFix?.map(q => q.range) ?? [e.range]));
+        return !ranges.some(r => (0, range_1.rangeCompare)(r, otherRange) !== 0 && (0, range_1.rangeIsSubsetOf)(otherRange, r)); // there is no smaller remove
+    });
+}
+exports.UNUSED_DEFINITION = {
+    /* this can be done better once we have types */
+    createSearch: config => flowr_search_builder_1.Q.all().filter(config.includeFunctionDefinitions ? flowr_search_filters_1.FlowrFilterCombinator.is(vertex_1.VertexType.VariableDefinition).or(vertex_1.VertexType.FunctionDefinition) : vertex_1.VertexType.VariableDefinition),
+    processSearchResult: (elements, config, data) => {
+        const metadata = {
+            totalConsidered: 0
+        };
+        return {
+            results: onlyKeepSupersetOfUnused(elements.getElements().flatMap(element => {
+                metadata.totalConsidered++;
+                const dfgVertex = data.dataflow.graph.getVertex(element.node.info.id);
+                if (!dfgVertex || (!(0, vertex_1.isVariableDefinitionVertex)(dfgVertex)
+                    && (0, vertex_1.isFunctionDefinitionVertex)(dfgVertex) && !config.includeFunctionDefinitions)) {
+                    return undefined;
+                }
+                const ingoingEdges = data.dataflow.graph.ingoingEdges(dfgVertex.id);
+                const interestedIn = (0, vertex_1.isVariableDefinitionVertex)(dfgVertex) ? InterestingEdgesVariable : InterestingEdgesFunction;
+                const ingoingInteresting = ingoingEdges?.values().some(e => (0, edge_1.edgeIncludesType)(e.types, interestedIn));
+                if (ingoingInteresting) {
+                    return undefined;
+                }
+                // found an unused definition
+                const variableName = element.node.lexeme;
+                return [{
+                        certainty: linter_format_1.LintingCertainty.Maybe,
+                        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)
+                    }];
+            }).filter(assert_1.isNotUndefined)),
+            '.meta': metadata
+        };
+    },
+    prettyPrint: {
+        [linter_format_1.LintingPrettyPrintContext.Query]: result => `Definition of \`${result.variableName}\` at ${(0, dfg_1.formatRange)(result.range)}`,
+        [linter_format_1.LintingPrettyPrintContext.Full]: result => `Definition of \`${result.variableName}\` at ${(0, dfg_1.formatRange)(result.range)} is unused`
+    },
+    info: {
+        name: 'Unused Definitions',
+        description: 'Checks for unused definitions.',
+        tags: [linter_tags_1.LintingRuleTag.Readability, linter_tags_1.LintingRuleTag.Smell, linter_tags_1.LintingRuleTag.QuickFix],
+        defaultConfig: {
+            includeFunctionDefinitions: true
+        }
+    }
+};
+//# sourceMappingURL=unused-definition.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/flowr",
-  "version": "2.2.15",
+  "version": "2.3.0",
   "description": "Static Dataflow Analyzer and Program Slicer for the R Programming Language",
   "types": "dist/src/index.d.ts",
   "repository": {
@@ -39,6 +39,7 @@
     "wiki:cfg": "ts-node src/documentation/print-cfg-wiki.ts",
     "wiki:linter": "ts-node src/documentation/print-linter-wiki.ts",
     "gen:readme": "ts-node src/documentation/print-readme.ts",
+    "gen:linter-issue": "ts-node src/documentation/print-linter-issue.ts",
     "build": "tsc --project .",
     "build-dev": "npm run build && npm run build:copy-wasm",
     "build:bundle-flowr": "npm run build && esbuild --bundle dist/src/cli/flowr.js --platform=node --tree-shaking=true --bundle --minify --external:clipboardy --target=node22 --outfile=dist/src/cli/flowr.min.js && npm run build:copy-wasm",
@@ -175,7 +176,7 @@
   "devDependencies": {
     "@commitlint/cli": "^19.7.1",
     "@commitlint/config-angular": "^19.7.1",
-    "@eagleoutice/eslint-config-flowr": "^1.0.17",
+    "@eagleoutice/eslint-config-flowr": "^1.0.19",
     "@eslint/eslintrc": "^3.2.0",
     "@eslint/js": "^9.20.0",
     "@j-ulrich/release-it-regex-bumper": "^5.3.0",
@@ -184,6 +185,7 @@
     "@types/n-readlines": "^1.0.6",
     "@types/n3": "^1.21.1",
     "@types/object-hash": "^3.0.6",
+    "@types/seedrandom": "^3.0.8",
     "@types/semver": "^7.5.8",
     "@types/tmp": "^0.2.6",
     "@types/ws": "^8.5.14",
@@ -215,6 +217,7 @@
     "object-hash": "^3.0.0",
     "object-sizeof": "^2.6.5",
     "rotating-file-stream": "^3.2.6",
+    "seedrandom": "^3.0.5",
     "semver": "^7.7.1",
     "tar": "^7.4.3",
     "tmp": "^0.2.3",

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

@@ -1,5 +1,6 @@
 import type { NormalizedAst } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { DataflowInformation } from '../dataflow/info';
+import type { FlowrConfigOptions } from '../config';
 export interface BaseQueryFormat {
     /** used to select the query type :) */
     readonly type: string;
@@ -14,4 +15,5 @@ export interface BaseQueryResult {
 export interface BasicQueryData {
     readonly ast: NormalizedAst;
     readonly dataflow: DataflowInformation;
+    readonly config: FlowrConfigOptions;
 }

package/queries/catalog/call-context-query/call-context-query-executor.d.ts

@@ -9,4 +9,4 @@ import type { BasicQueryData } from '../../base-query-format';
  *    This happens during the main resolution!
  * 4. Attach `linkTo` calls to the respective calls.
  */
-export declare function executeCallContextQueries({ dataflow: { graph }, ast }: BasicQueryData, queries: readonly CallContextQuery[]): CallContextQueryResult;
+export declare function executeCallContextQueries({ dataflow: { graph }, ast, config }: BasicQueryData, queries: readonly CallContextQuery[]): CallContextQueryResult;

package/queries/catalog/call-context-query/call-context-query-executor.js

@@ -171,7 +171,7 @@ function isParameterDefaultValue(nodeId, ast) {
  *    This happens during the main resolution!
  * 4. Attach `linkTo` calls to the respective calls.
  */
-function executeCallContextQueries({ dataflow: { graph }, ast }, queries) {
+function executeCallContextQueries({ dataflow: { graph }, ast, config }, queries) {
     /* omit performance page load */
     const now = Date.now();
     /* the node id and call targets if present */
@@ -180,7 +180,7 @@ function executeCallContextQueries({ dataflow: { graph }, ast }, queries) {
     const { promotedQueries, requiresCfg } = promoteQueryCallNames(queries);
     let cfg = undefined;
     if (requiresCfg) {
-        cfg = (0, extract_cfg_1.extractCfg)(ast, graph, []);
+        cfg = (0, extract_cfg_1.extractCfg)(ast, config, graph, []);
     }
     const queriesWhichWantAliases = promotedQueries.filter(q => q.includeAliases);
     for (const [nodeId, info] of graph.vertices(true)) {