@eagleoutice/flowr 2.2.14 → 2.2.16

package/documentation/print-linter-issue.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const log_1 = require("../../test/functionality/_helper/log");
+const doc_types_1 = require("./doc-util/doc-types");
+const path_1 = __importDefault(require("path"));
+const linter_tags_1 = require("../linter/linter-tags");
+const doc_general_1 = require("./doc-util/doc-general");
+const doc_files_1 = require("./doc-util/doc-files");
+const linter_rules_1 = require("../linter/linter-rules");
+/* this prints the yaml configuration for the GitHub issue template to request a new linter rule / an update */
+function summarizeIfTooLong(text, maxLength = 52) {
+    if (text.length <= maxLength) {
+        return text;
+    }
+    return text.slice(0, maxLength - 1) + '…';
+}
+function getText() {
+    const types = (0, doc_types_1.getTypesFromFolder)({
+        rootFolder: path_1.default.resolve('./src/linter/')
+    });
+    return `
+name: Linting Rule
+description: Suggest either a new linting rule or an improvement to an existing one. 
+title: "[Linter]: "
+labels: ["flowr linter"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thank you for suggesting a new linting rule or an improvement to an existing one. Please provide as much detail as possible to help us understand your request. See the [Linter Wiki Page](${doc_files_1.FlowrWikiBaseRef}/Linter) for more information.
+  - type: textarea
+    id: description
+    attributes:
+      label: Description
+      description: |
+        Please provide a detailed description of the linting rule you are suggesting or the improvement you would like to see. Include examples if possible.
+    validations:
+      required: true
+  - type: dropdown
+    id: linting-rule
+    attributes:
+      label: Linting Rule
+      description: |
+        Select the linting rule that you are suggesting or improving. If it is a new rule, select "New Rule".
+      options:
+        - New Rule
+${(0, doc_general_1.prefixLines)(Object.keys(linter_rules_1.LintingRules).sort().map(name => {
+        const rule = linter_rules_1.LintingRules[name];
+        return `- ${rule.info.name}`;
+    }).join('\n'), '        ')}
+      default: 0
+  - type: checkboxes
+    id: tags
+    attributes:
+      label: Meta Information
+      description: Select any tags that you think apply to the linting rule you are suggesting. If you try to suggest a new linting rule, please only select those that you think apply after your suggestions.
+      options:
+${(0, doc_general_1.prefixLines)(Object.entries(linter_tags_1.LintingRuleTag).map(([name]) => {
+        return `- label: '**${name}**: ${summarizeIfTooLong((0, doc_types_1.getDocumentationForType)('LintingRuleTag::' + name, types.info).replaceAll(/\n/g, ' ').replaceAll('\'', '\\\'').trim())}'\n  required: false`;
+    }).join('\n'), '        ')}
+`.trim();
+}
+/** if we run this script, we want a Markdown representation of the capabilities */
+if (require.main === module) {
+    (0, log_1.setMinLevelOfAllLogs)(6 /* LogLevel.Fatal */);
+    console.log(getText());
+}
+//# sourceMappingURL=print-linter-issue.js.map

package/documentation/print-linter-wiki.js

@@ -12,48 +12,147 @@ 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);
+    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 +160,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

@@ -34,6 +34,8 @@ const flowr_search_builder_1 = require("../search/flowr-search-builder");
 const vertex_1 = require("../dataflow/graph/vertex");
 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");
 (0, doc_query_1.registerQueryDocumentation)('call-context', {
     name: 'Call-Context Query',
     type: 'active',
@@ -477,6 +479,84 @@ Here, \`resolveValue\` tells the dependency query to resolve the value of this a
 		`;
     }
 });
+(0, doc_query_1.registerQueryDocumentation)('linter', {
+    name: 'Linter Query',
+    type: 'active',
+    shortDescription: 'Lints a given R script for common issues.',
+    functionName: dependencies_query_executor_1.executeDependenciesQuery.name,
+    functionFile: '../queries/catalog/linter-query/linter-query-executor.ts',
+    buildExplanation: async (shell) => {
+        const exampleCode = 'read.csv("i_do_not_exist.csv")';
+        return `
+This query lints a given R script for common issues, such as missing files, unused variables, and more.
+
+In other words, if you have a script simply reading: \`${exampleCode}\`, the following query returns all smells detected:
+${await (0, doc_query_1.showQuery)(shell, exampleCode, [{
+                type: 'linter'
+            }], { showCode: false, collapseQuery: true })}
+
+You can also configure which rules to apply and what settings to use for these rules. 
+We welcome any feedback and suggestions for new rules on this (consider opening a [new issue](${doc_issue_1.NewIssueUrl})).
+		`;
+    }
+});
+(0, doc_query_1.registerQueryDocumentation)('control-flow', {
+    name: 'Control-Flow Query',
+    type: 'active',
+    shortDescription: 'Provides the control-flow of the program.',
+    functionName: control_flow_query_executor_1.executeControlFlowQuery.name,
+    functionFile: '../queries/catalog/control-flow-query/control-flow-query-executor.ts',
+    buildExplanation: async (shell) => {
+        const exampleCode = 'if(TRUE) 1 else 2';
+        return `
+This control-flow query provides you access to the control flow graph.
+
+In other words, if you have a script simply reading: \`${exampleCode}\`, the following query returns the CFG:
+${await (0, doc_query_1.showQuery)(shell, exampleCode, [{
+                type: 'control-flow'
+            }], { showCode: false, collapseQuery: true, collapseResult: true })}
+
+You can also overwrite the simplification passes to tune the perspective. for example, if you want to have basic blocks:
+${await (0, doc_query_1.showQuery)(shell, exampleCode, [{
+                type: 'control-flow',
+                config: {
+                    simplificationPasses: ['unique-cf-sets', 'to-basic-blocks']
+                }
+            }], { showCode: false, collapseResult: true })}
+
+this produces: 
+
+${await (0, doc_cfg_1.printCfgCode)(shell, exampleCode, { showCode: false, prefix: 'flowchart RL\n', simplifications: ['to-basic-blocks'] })}
+
+
+If, on the other hand, you want to prune dead code edges:
+${await (0, doc_query_1.showQuery)(shell, exampleCode, [{
+                type: 'control-flow',
+                config: {
+                    simplificationPasses: ['unique-cf-sets', 'analyze-dead-code']
+                }
+            }], { showCode: false, collapseResult: true })}
+
+this produces:
+
+${await (0, doc_cfg_1.printCfgCode)(shell, exampleCode, { showCode: false, prefix: 'flowchart RL\n', simplifications: ['analyze-dead-code'] })}
+
+
+Or, completely remove dead code:
+${await (0, doc_query_1.showQuery)(shell, exampleCode, [{
+                type: 'control-flow',
+                config: {
+                    simplificationPasses: ['unique-cf-sets', 'analyze-dead-code', 'remove-dead-code']
+                }
+            }], { showCode: false, collapseResult: true })}
+
+this produces:
+
+${await (0, doc_cfg_1.printCfgCode)(shell, exampleCode, { showCode: false, prefix: 'flowchart RL\n', simplifications: ['analyze-dead-code', 'remove-dead-code'] })}
+
+		`;
+    }
+});
 (0, doc_query_1.registerQueryDocumentation)('location-map', {
     name: 'Location Map Query',
     type: 'active',
@@ -484,9 +564,8 @@ Here, \`resolveValue\` tells the dependency query to resolve the value of this a
     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);