@eagleoutice/flowr 2.2.15 → 2.3.0

package/documentation/print-linter-wiki.js

@@ -12,48 +12,151 @@ const shell_1 = require("../r-bridge/shell");
 const doc_query_1 = require("./doc-util/doc-query");
 const doc_types_1 = require("./doc-util/doc-types");
 const path_1 = __importDefault(require("path"));
-async function getText(shell) {
-    const rVersion = (await shell.usedRVersion())?.format() ?? 'unknown';
-    return `${(0, doc_auto_gen_1.autoGenHeader)({ filename: module.filename, purpose: 'linter', rVersion })}
-
-This page describes the flowR linter, which is a tool that utilizes flowR's dataflow analysis to find common issues in R scripts. The linter can currently be used through the linter [query](${doc_files_1.FlowrWikiBaseRef}/Query%20API).
+const doc_repl_1 = require("./doc-util/doc-repl");
+const doc_structure_1 = require("./doc-util/doc-structure");
+const linter_tags_1 = require("../linter/linter-tags");
+const html_hover_over_1 = require("../util/html-hover-over");
+const strings_1 = require("../util/text/strings");
+const assert_1 = require("../util/assert");
+const doc_print_1 = require("./doc-util/doc-print");
+const doc_functions_1 = require("./doc-util/doc-functions");
+const SpecialTagColors = {
+    [linter_tags_1.LintingRuleTag.Bug]: 'red',
+    [linter_tags_1.LintingRuleTag.Security]: 'orange',
+    [linter_tags_1.LintingRuleTag.Smell]: 'yellow',
+    [linter_tags_1.LintingRuleTag.QuickFix]: 'lightgray',
+};
+function makeTagBadge(name, info) {
+    const doc = (0, doc_types_1.getDocumentationForType)('LintingRuleTag::' + name, info, '', true).replaceAll('\n', ' ');
+    return (0, html_hover_over_1.textWithTooltip)(`<a href='#${name}'>![` + name + '](https://img.shields.io/badge/' + name.toLowerCase() + `-${SpecialTagColors[name] ?? 'teal'}) </a>`, doc);
+}
+function prettyPrintExpectedOutput(expected) {
+    if (expected.trim() === '[]') {
+        return '* no lints';
+    }
+    let lines = expected.trim().split('\n');
+    if (lines.length <= 1) {
+        return expected;
+    }
+    //
+    lines = expected.trim().replace(/^\s*\[+\s*{*/m, '').replace(/\s*}*\s*]+\s*$/, '').split('\n').filter(l => l.trim() !== '');
+    /* take the indentation of the last line and remove it from all but the first: */
+    const indentation = lines[lines.length - 1].match(/^\s*/)?.[0] ?? '';
+    return lines.map((line, i) => {
+        if (i === 0) {
+            return line;
+        }
+        return line.replace(new RegExp('^' + indentation, 'g'), '');
+    }).join('\n');
+}
+function buildSamplesFromLinterTestCases(shell, testFile) {
+    const reports = (0, doc_functions_1.getFunctionsFromFolder)({ files: [path_1.default.resolve('test/functionality/linter/' + testFile)], fname: /assertLinter/ });
+    if (reports.info.length === 0) {
+        return '';
+    }
+    let result = `#### Additional Examples
+	
+These examples are synthesized from the test cases in: ${(0, doc_files_1.linkFlowRSourceFile)('test/functionality/linter/' + testFile)}\n\n`;
+    for (const report of reports.info) {
+        const args = report.arguments;
+        if (args.length < 5) {
+            console.error('Test case for linter rule ' + report.name + ' does not have enough arguments! Expected at least 5, got ' + args.length);
+            continue;
+        }
+        const testName = args[0].getText(report.source);
+        if (report.comments?.some(c => c.includes('@ignore-in-wiki'))) {
+            console.warn(`Skipping test case for linter rule ${testName} (${testFile}) as it is marked with @ignore-in-wiki`);
+            continue;
+        }
+        // drop any quotes around the test name
+        const testNameClean = testName.replace(/^['"]|['"]$/g, '');
+        result += `\n${(0, doc_structure_1.section)('Test Case: ' + testNameClean, 4)}
 
-## Linting Rules
+${report.comments ? report.comments.map(c => `> ${c}`).join('\n') + '\n' : ''}
+Given the following input:
+${(0, doc_code_1.codeBlock)('r', args[2].getText(report.source).replace(/^['"]|['"]$/g, '').replace(/\\n/g, '\n'))}
+${args.length >= 7 ? `\nAnd using the following [configuration](#configuration): ${(0, doc_code_1.codeBlock)('ts', prettyPrintExpectedOutput(args[6].getText(report.source)))}` : ''}
 
-The following linting rules are available:
+We expect the linter to report the following:
+${(0, doc_code_1.codeBlock)('ts', prettyPrintExpectedOutput(args[4].getText(report.source)))}
 
-${await rule(shell, 'deprecated-functions', 'DeprecatedFunctionsConfig', 'Deprecated Functions', 'This rule detects the usage of deprecated functions in code based on a predefined list of known deprecated functions.', `
+See [here](${(0, doc_types_1.getTypePathLink)({ filePath: report.source.fileName, lineNumber: report.lineNumber })}) for the test-case implementation.
+		`;
+    }
+    return result;
+}
+function registerRules(rVersion, shell, tagTypes, format = 'short') {
+    const ruleExplanations = new Map();
+    rule(shell, 'deprecated-functions', 'DeprecatedFunctionsConfig', 'DEPRECATED_FUNCTIONS', 'lint-deprecated-functions', `
 first <- data.frame(x = c(1, 2, 3), y = c(1, 2, 3))
 second <- data.frame(x = c(1, 3, 2), y = c(1, 3, 2))
 dplyr::all_equal(first, second)
-`)}
-
-${await rule(shell, 'file-path-validity', 'FilePathValidityConfig', 'File Path Validity', 'This rule finds places in the code where files are being read from. In such places, it checks whether the file path is valid and whether the file exists on disk.', `
+`, tagTypes);
+    rule(shell, 'file-path-validity', 'FilePathValidityConfig', 'FILE_PATH_VALIDITY', 'lint-file-path-validity', `
 my_data <- read.csv("C:/Users/me/Documents/My R Scripts/Reproducible.csv")
-`)}
+`, tagTypes);
+    rule(shell, 'absolute-file-paths', 'AbsoluteFilePathConfig', 'ABSOLUTE_PATH', 'lint-absolute-path', `
+read.csv("C:/Users/me/Documents/My R Scripts/Reproducible.csv")
+`, tagTypes);
+    rule(shell, 'unused-definitions', 'UnusedDefinitionConfig', 'UNUSED_DEFINITION', 'lint-unused-definition', `
+x <- 42
+y <- 3
+print(x)
+`, tagTypes);
+    rule(shell, 'seeded-randomness', 'SeededRandomnessConfig', 'SEEDED_RANDOMNESS', 'lint-seeded-randomness', 'runif(1)', tagTypes);
+    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];
+        const tags = rule.info.tags.toSorted((a, b) => {
+            // sort but specials first
+            if (a === b) {
+                return 0;
+            }
+            if (SpecialTagColors[a] && SpecialTagColors[b]) {
+                return SpecialTagColors[b].localeCompare(SpecialTagColors[a]);
+            }
+            else if (SpecialTagColors[a]) {
+                return -1;
+            }
+            else if (SpecialTagColors[b]) {
+                return 1;
+            }
+            return a.localeCompare(b);
+        }).map(t => makeTagBadge(t, types)).join(' ');
+        if (format === 'short') {
+            ruleExplanations.set(name, () => Promise.resolve(`
+	**[${rule.info.name}](${doc_files_1.FlowrWikiBaseRef}/lint-${name}):** ${rule.info.description} [see ${(0, doc_types_1.shortLinkFile)(ruleType, types)}]\\
+	${tags}
 
-    `.trim();
-}
-async function rule(shell, name, configType, friendlyName, description, example) {
-    const types = (0, doc_types_1.getTypesFromFolderAsMermaid)({
-        rootFolder: path_1.default.resolve('./src/linter/'),
-        typeName: configType,
-        inlineTypes: doc_types_1.mermaidHide
-    });
-    return `
-### ${friendlyName} (\`${name}\`)
-	
-${description}
+		`.trim()));
+        }
+        else {
+            ruleExplanations.set(name, async () => `
 
-<details>
+${(0, doc_auto_gen_1.autoGenHeader)({ filename: module.filename, purpose: 'linter', rVersion })}
+${(0, doc_structure_1.section)(rule.info.name + `&emsp;<sup>[<a href="${doc_files_1.FlowrWikiBaseRef}/Linter">overview</a>]</sup>`, 2, name)}
 
-#### Configuration
+${tags}
+ 
+${rule.info.description}\\
+_This linting rule is implemented in ${(0, doc_types_1.shortLinkFile)(ruleType, types)}._
 
-Linting rules can be configured by passing a configuration object to the linter query as shown in the example below. The \`${name}\` rule accepts the following configuration options:
 
-${Object.getOwnPropertyNames(linter_rules_1.LintingRules[name].defaultConfig).sort().map(key => `- ${(0, doc_types_1.shortLink)(`${configType}:::${key}`, types.info)}\\\n${(0, doc_types_1.getDocumentationForType)(`${configType}::${key}`, types.info)}`).join('\n')}
+### Configuration
 
-#### Example
+Linting rules can be configured by passing a configuration object to the linter query as shown in the example below.
+The \`${name}\` rule accepts the following configuration options:
+
+${Object.getOwnPropertyNames(linter_rules_1.LintingRules[name].info.defaultConfig).sort().map(key => `- ${(0, doc_types_1.shortLink)(`${configType}:::${key}`, types)}\\\n${(0, doc_types_1.getDocumentationForType)(`${configType}::${key}`, types)}`).join('\n')}
+
+### Examples
 
 ${(0, doc_code_1.codeBlock)('r', example)}
 
@@ -61,16 +164,102 @@ The linting query can be used to run this rule on the above example:
 
 ${await (0, doc_query_1.showQuery)(shell, example, [{ type: 'linter', rules: [{ name, config: {} }] }], { collapseQuery: true })}
 
-</details>
-	`.trim();
+${buildSamplesFromLinterTestCases(shell, `${testfile}.test.ts`)}
+
+		`.trim());
+        }
+    }
+    return ruleExplanations;
+}
+function getAllLintingRulesWitTag(tag) {
+    return Object.entries(linter_rules_1.LintingRules).filter(([_, rule]) => rule.info.tags.includes(tag)).map(([name]) => name);
+}
+function linkToRule(name) {
+    return `[${name}](${doc_files_1.FlowrWikiBaseRef}/lint-${name})`;
+}
+async function getTextMainPage(shell, tagTypes, rVersion) {
+    const rules = registerRules(rVersion, shell, tagTypes.info);
+    return `${(0, doc_auto_gen_1.autoGenHeader)({ filename: module.filename, purpose: 'linter', rVersion })}
+
+This page describes the flowR linter, which is a tool that utilizes flowR's dataflow analysis to find common issues in R scripts. The linter can currently be used through the linter [query](${doc_files_1.FlowrWikiBaseRef}/Query%20API).
+For example:
+
+${await (async () => {
+        const code = 'read.csv("/root/x.txt")';
+        const res = await (0, doc_query_1.showQuery)(shell, code, [{ type: 'linter' }], { showCode: false, collapseQuery: true, collapseResult: false });
+        return await (0, doc_repl_1.documentReplSession)(shell, [{
+                command: `:query @linter ${JSON.stringify(code)}`,
+                description: `
+The linter will analyze the code and return any issues found.
+Formatted more nicely, this returns:
+
+${res}
+		`
+            }]);
+    })()}
+
+${(0, doc_structure_1.section)('Linting Rules', 2, 'linting-rules')}
+
+The following linting rules are available:
+
+${await (async () => {
+        let result = '';
+        for (const k of Object.keys(linter_rules_1.LintingRules).sort()) {
+            const rule = rules.get(k);
+            (0, assert_1.guard)(rule !== undefined, `Linting rule ${k} is not documented!`);
+            result += '\n\n' + await rule();
+        }
+        return result;
+    })()}
+	
+${(0, doc_structure_1.section)('Tags', 2, 'tags')}
+
+We use tags to categorize linting rules. The following tags are available:
+
+| Tag/Badge&emsp;&emsp; | Description |
+| --- | :-- |
+${Object.entries(linter_tags_1.LintingRuleTag).map(([name, tag]) => {
+        return `| <a id="${tag}"></a> ${makeTagBadge(tag, tagTypes.info)} | ${(0, doc_types_1.getDocumentationForType)('LintingRuleTag::' + name, tagTypes.info).replaceAll(/\n/g, ' ')} (rule${getAllLintingRulesWitTag(tag).length === 1 ? '' : 's'}: ${(0, strings_1.joinWithLast)(getAllLintingRulesWitTag(tag).map(l => linkToRule(l))) || '_none_'}) | `;
+    }).join('\n')}
+	
+`.trim();
+}
+async function getRulesPages(shell, tagTypes, rVersion) {
+    const rules = registerRules(rVersion, shell, tagTypes.info, 'long');
+    const result = {};
+    for (const [name, rule] of rules) {
+        const filepath = path_1.default.resolve('./wiki', `lint-${name}.md`);
+        result[filepath] = await rule();
+    }
+    return result;
+}
+/** Maps file-names to their content, the 'main' file is named 'main' */
+async function getTexts(shell) {
+    const rVersion = (await shell.usedRVersion())?.format() ?? 'unknown';
+    const tagTypes = (0, doc_types_1.getTypesFromFolder)({
+        rootFolder: path_1.default.resolve('./src/linter/'),
+        inlineTypes: doc_types_1.mermaidHide
+    });
+    return {
+        'main': await getTextMainPage(shell, tagTypes, rVersion),
+        ...await getRulesPages(shell, tagTypes, rVersion)
+    };
 }
+/* As an intermediary solution to changing the wiki system, we make this script generate separate files for each linter rule using fixed paths */
 if (require.main === module) {
     (0, log_1.setMinLevelOfAllLogs)(6 /* LogLevel.Fatal */);
     const shell = new shell_1.RShell();
-    void getText(shell).then(str => {
-        console.log(str);
+    void (getTexts(shell).then(data => {
+        console.log(data['main']);
+        for (const [file, content] of Object.entries(data)) {
+            if (file === 'main') {
+                continue; // main is printed above
+            }
+            const filepath = path_1.default.resolve('./wiki', file);
+            (0, doc_print_1.writeWikiTo)(content, filepath);
+        }
     }).finally(() => {
         shell.close();
-    });
+    }));
 }
 //# sourceMappingURL=print-linter-wiki.js.map

package/documentation/print-linting-and-testing-wiki.js

@@ -11,10 +11,10 @@ const doc_types_1 = require("./doc-util/doc-types");
 const path_1 = __importDefault(require("path"));
 const doc_auto_gen_1 = require("./doc-util/doc-auto-gen");
 function getText() {
-    const { info } = (0, doc_types_1.getTypesFromFolderAsMermaid)({
+    const { info } = (0, doc_types_1.getTypesFromFolder)({
         rootFolder: path_1.default.resolve('./test'),
         files: [path_1.default.resolve('./src/dataflow/graph/dataflowgraph-builder.ts')],
-        typeName: 'parameter',
+        typeNameForMermaid: 'parameter',
         inlineTypes: doc_types_1.mermaidHide
     });
     return `${(0, doc_auto_gen_1.autoGenHeader)({ filename: module.filename, purpose: 'linting and testing definitions' })}
@@ -188,8 +188,6 @@ See [test/performance](${doc_files_1.RemoteFlowrFilePathBaseRef}test/performance
 Using the vitest Extension for Visual Studio Code, you can start tests directly from the definition and explore your suite in the Testing tab.
 To get started, install the [vitest Extension](https://marketplace.visualstudio.com/items?itemName=vitest.explorer).
 
-![vscode market place](img/vs-code-vitest.png)
-
 |               Testing Tab               | In Code                               |
 |:---------------------------------------:|:-------------------------------------:|
 | ![testing tab](img/testing-vs-code.png) | ![in code](img/testing-vs-code-2.png) |

package/documentation/print-normalized-ast-wiki.js

@@ -23,9 +23,9 @@ const default_pipelines_1 = require("../core/steps/pipeline/default-pipelines");
 async function getText(shell) {
     const rversion = (await shell.usedRVersion())?.format() ?? 'unknown';
     const now = performance.now();
-    const types = (0, doc_types_1.getTypesFromFolderAsMermaid)({
+    const types = (0, doc_types_1.getTypesFromFolder)({
         rootFolder: path_1.default.resolve('./src'),
-        typeName: 'RNode',
+        typeNameForMermaid: 'RNode',
         inlineTypes: doc_types_1.mermaidHide
     });
     const elapsed = performance.now() - now;
@@ -70,7 +70,7 @@ In general, we provide node types for:
 Every node is a link, which directly refers to the implementation in the source code.
 Grayed-out parts are used for structuring the AST, grouping together related nodes.
 
-${(0, doc_code_1.codeBlock)('mermaid', types.text)}
+${(0, doc_code_1.codeBlock)('mermaid', types.mermaid)}
 
 _The generation of the class diagram required ${(0, time_1.printAsMs)(elapsed)}._
 </details>

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',
@@ -564,9 +581,8 @@ ${await (0, doc_cfg_1.printCfgCode)(shell, exampleCode, { showCode: false, prefi
     functionName: location_map_query_executor_1.executeLocationMapQuery.name,
     functionFile: '../queries/catalog/location-map-query/location-map-query-executor.ts',
     buildExplanation: async (shell) => {
-        const types = (0, doc_types_1.getTypesFromFolderAsMermaid)({
+        const types = (0, doc_types_1.getTypesFromFolder)({
             files: [path_1.default.resolve('./src/util/range.ts')],
-            typeName: 'SourceRange'
         });
         const exampleCode = 'x + 1\nx * 2';
         return `

package/documentation/print-readme.js

@@ -14,6 +14,7 @@ const doc_repl_1 = require("./doc-util/doc-repl");
 const doc_auto_gen_1 = require("./doc-util/doc-auto-gen");
 const doc_general_1 = require("./doc-util/doc-general");
 const doc_dfg_1 = require("./doc-util/doc-dfg");
+const doc_query_1 = require("./doc-util/doc-query");
 async function getText(shell) {
     const dateOptions = { year: 'numeric', month: 'short', day: 'numeric' };
     return `
@@ -31,6 +32,28 @@ available for [VSCode](${doc_files_1.FlowrVsCode}), [Positron](${doc_files_1.Flo
 and [Docker](${doc_files_1.FlowrDockerRef}).
 It offers a wide variety of features, for example:
 
+* 🐞 **code linting**\\
+   Analyze your R scripts for common issues and potential bugs (see the [wiki page](${doc_files_1.FlowrGithubBaseRef}/flowr/wiki/Linter) for more information on the currently supported linters).
+
+	${(0, doc_general_1.prefixLines)((0, doc_structure_1.details)('Example: Linting code with flowR', `To lint your code, you can use the [REPL](${doc_files_1.FlowrWikiBaseRef}/Interface#using-the-repl) or the [Visual Studio Code extension](${doc_files_1.FlowrVsCode}) (see [vscode-flowr#283](https://github.com/flowr-analysis/vscode-flowr/pull/283)).
+	
+${await (async () => {
+        const code = 'read.csv("/root/x.txt")';
+        const res = await (0, doc_query_1.showQuery)(shell, code, [{ type: 'linter' }], { showCode: false, collapseQuery: true, collapseResult: false });
+        return await (0, doc_repl_1.documentReplSession)(shell, [{
+                command: `:query @linter ${JSON.stringify(code)}`,
+                description: `
+The linter will analyze the code and return any issues found.
+Formatted more nicely, this returns:
+
+${res}
+		`
+            }]);
+    })()}
+	   
+	   `), '    ')}
+
+
 * 🍕 **program slicing**\\
    Given a point of interest like the visualization of a plot, _flowR_ reduces the program to just the parts which are relevant
    for the computation of the point of interest.
@@ -117,7 +140,7 @@ You can enter ${(0, doc_cli_option_1.getReplCommand)('help')} to gain more infor
 
 <summary>Example REPL session</summary>
 
-![Example of a simple REPL session](wiki/gif/repl-demo.gif)
+![Example of a simple REPL session](wiki/gif/repl-demo-opt.gif)
 
 </details>
 

package/documentation/print-search-wiki.js

@@ -15,9 +15,8 @@ const path_1 = __importDefault(require("path"));
 const flowr_search_executor_1 = require("../search/flowr-search-executor");
 async function getText(shell) {
     const rversion = (await shell.usedRVersion())?.format() ?? 'unknown';
-    const types = (0, doc_types_1.getTypesFromFolderAsMermaid)({
+    const types = (0, doc_types_1.getTypesFromFolder)({
         rootFolder: path_1.default.resolve('./src/search/'),
-        typeName: 'FlowrSearchGenerator',
         inlineTypes: doc_types_1.mermaidHide
     });
     return `${(0, doc_auto_gen_1.autoGenHeader)({ filename: module.filename, purpose: 'search API', rVersion: rversion })}

package/linter/linter-executor.d.ts

@@ -3,7 +3,9 @@ import type { NormalizedAst } from '../r-bridge/lang-4.x/ast/model/processing/de
 import type { DataflowInformation } from '../dataflow/info';
 import type { LintingResults } from './linter-format';
 import type { DeepPartial } from 'ts-essentials';
+import type { FlowrConfigOptions } from '../config';
 export declare function executeLintingRule<Name extends LintingRuleNames>(ruleName: Name, input: {
     normalize: NormalizedAst;
     dataflow: DataflowInformation;
-}, config?: DeepPartial<LintingRuleConfig<Name>>): LintingResults<Name>;
+    config: FlowrConfigOptions;
+}, lintingRuleConfig?: DeepPartial<LintingRuleConfig<Name>>): LintingResults<Name>;

package/linter/linter-executor.js

@@ -4,9 +4,10 @@ exports.executeLintingRule = executeLintingRule;
 const linter_rules_1 = require("./linter-rules");
 const flowr_search_executor_1 = require("../search/flowr-search-executor");
 const flowr_search_1 = require("../search/flowr-search");
-function executeLintingRule(ruleName, input, config) {
+const objects_1 = require("../util/objects");
+function executeLintingRule(ruleName, input, lintingRuleConfig) {
     const rule = linter_rules_1.LintingRules[ruleName];
-    const fullConfig = { ...rule.defaultConfig, ...config };
+    const fullConfig = (0, objects_1.deepMergeObject)(rule.info.defaultConfig, lintingRuleConfig);
     const ruleSearch = rule.createSearch(fullConfig, input);
     const searchStart = Date.now();
     const searchResult = (0, flowr_search_executor_1.runSearch)(ruleSearch, input);

package/linter/linter-format.d.ts

@@ -6,7 +6,28 @@ import type { TransformerNames } from '../search/search-executor/search-transfor
 import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { LintingRuleConfig, LintingRuleMetadata, LintingRuleNames, LintingRuleResult } from './linter-rules';
 import type { DataflowInformation } from '../dataflow/info';
-import type { DeepPartial } from 'ts-essentials';
+import type { FlowrConfigOptions } from '../config';
+import type { DeepPartial, DeepReadonly } from 'ts-essentials';
+import type { LintingRuleTag } from './linter-tags';
+import type { SourceRange } from '../util/range';
+export interface LinterRuleInformation<Config extends MergeableRecord = never> {
+    /** Human-Readable name of the linting rule. */
+    readonly name: string;
+    /**
+     * The default config for this linting rule.
+     * This config is combined with the user config when executing the rule.
+     */
+    readonly defaultConfig: NoInfer<DeepReadonly<Config>>;
+    /**
+     * A short list of tags that describe and categorize the linting rule.
+     */
+    readonly tags: readonly LintingRuleTag[];
+    /**
+     * A short description of the linting rule.
+     * This is used to display the rule in the UI and to provide a brief overview of what the rule does.
+     */
+    readonly description: string;
+}
 /**
  * The base interface for a linting rule, which contains all of its relevant settings.
  * The registry of valid linting rules is stored in {@link LintingRules}.
@@ -27,26 +48,54 @@ export interface LintingRule<Result extends LintingResult, Metadata extends Merg
     readonly processSearchResult: (elements: FlowrSearchElements<Info, Elements>, config: Config, data: {
         normalize: NormalizedAst;
         dataflow: DataflowInformation;
+        config: FlowrConfigOptions;
     }) => {
         results: Result[];
         '.meta': Metadata;
     };
     /**
-     * A function used to pretty-print the given linting result.
-     * By default, the {@link LintingResult#certainty} is automatically printed alongside this information.
+     * A set of functions used to pretty-print the given linting result.
+     * By default, the {@link LintingResult#certainty} and whether any {@link LintingResult#quickFix} values are available is automatically printed alongside this information.
+     */
+    readonly prettyPrint: {
+        [C in LintingPrettyPrintContext]: (result: Result, metadata: Metadata) => string;
+    };
+    readonly info: LinterRuleInformation<NoInfer<Config>>;
+}
+interface BaseQuickFix {
+    /**
+     * The type of the quick fix.
      */
-    readonly prettyPrint: (result: Result, metadata: Metadata) => string;
+    readonly type: string;
     /**
-     * The default config for this linting rule.
-     * The default config is combined with the user config when executing the rule.
+     * A short, human-readable description of the quick fix.
      */
-    readonly defaultConfig: NoInfer<Config>;
+    readonly description: string;
+    /**
+     * The range of the text that should be replaced.
+     */
+    readonly range: SourceRange;
 }
+export interface LintQuickFixReplacement extends BaseQuickFix {
+    readonly type: 'replace';
+    /**
+     * The text that should replace the given range.
+     */
+    readonly replacement: string;
+}
+export interface LintQuickFixRemove extends BaseQuickFix {
+    readonly type: 'remove';
+}
+export type LintQuickFix = LintQuickFixReplacement | LintQuickFixRemove;
 /**
  * A linting result for a single linting rule match.
  */
 export interface LintingResult {
     readonly certainty: LintingCertainty;
+    /**
+     * If available, what to do to fix the linting result.
+     */
+    readonly quickFix?: LintQuickFix[];
 }
 export interface ConfiguredLintingRule<Name extends LintingRuleNames = LintingRuleNames> {
     readonly name: Name;
@@ -60,6 +109,17 @@ export interface LintingResults<Name extends LintingRuleNames> {
     };
 }
 export declare enum LintingCertainty {
+    /**
+     * The linting rule cannot say for sure whether the result is correct or not.
+     */
     Maybe = "maybe",
+    /**
+     * The linting rule is certain that the reported lint is real.
+     */
     Definitely = "definitely"
 }
+export declare enum LintingPrettyPrintContext {
+    Query = "query",
+    Full = "full"
+}
+export {};

package/linter/linter-format.js

@@ -1,9 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LintingCertainty = void 0;
+exports.LintingPrettyPrintContext = exports.LintingCertainty = void 0;
 var LintingCertainty;
 (function (LintingCertainty) {
+    /**
+     * The linting rule cannot say for sure whether the result is correct or not.
+     */
     LintingCertainty["Maybe"] = "maybe";
+    /**
+     * The linting rule is certain that the reported lint is real.
+     */
     LintingCertainty["Definitely"] = "definitely";
 })(LintingCertainty || (exports.LintingCertainty = LintingCertainty = {}));
+var LintingPrettyPrintContext;
+(function (LintingPrettyPrintContext) {
+    LintingPrettyPrintContext["Query"] = "query";
+    LintingPrettyPrintContext["Full"] = "full";
+})(LintingPrettyPrintContext || (exports.LintingPrettyPrintContext = LintingPrettyPrintContext = {}));
 //# sourceMappingURL=linter-format.js.map