@eagleoutice/flowr 2.10.3 → 2.10.5

package/documentation/wiki-absint.js

@@ -3,8 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WikiAbsint = void 0;
 const absint_visitor_1 = require("../abstract-interpretation/absint-visitor");
 const abstract_domain_1 = require("../abstract-interpretation/domains/abstract-domain");
+const bounded_set_domain_1 = require("../abstract-interpretation/domains/bounded-set-domain");
 const interval_domain_1 = require("../abstract-interpretation/domains/interval-domain");
 const lattice_1 = require("../abstract-interpretation/domains/lattice");
+const multi_value_state_domain_1 = require("../abstract-interpretation/domains/multi-value-state-domain");
 const state_abstract_domain_1 = require("../abstract-interpretation/domains/state-abstract-domain");
 const semantic_cfg_guided_visitor_1 = require("../control-flow/semantic-cfg-guided-visitor");
 const identifier_1 = require("../dataflow/environments/identifier");
@@ -15,10 +17,13 @@ const doc_code_1 = require("./doc-util/doc-code");
 const doc_structure_1 = require("./doc-util/doc-structure");
 const doc_maker_1 = require("./wiki-mk/doc-maker");
 class IntervalInferenceVisitor extends absint_visitor_1.AbstractInterpretationVisitor {
+    constructor(config) {
+        super(config, state_abstract_domain_1.StateAbstractDomain.top(interval_domain_1.IntervalDomain.top()));
+    }
     onNumberConstant({ vertex, node }) {
         super.onNumberConstant({ vertex, node });
         const interval = new interval_domain_1.IntervalDomain([node.content.num, node.content.num]);
-        this.updateState(node.info.id, interval);
+        this.currentState.set(node.info.id, interval);
     }
     onFunctionCall({ call }) {
         super.onFunctionCall({ call });
@@ -32,9 +37,9 @@ class IntervalInferenceVisitor extends absint_visitor_1.AbstractInterpretationVi
             // We map the numerical operation to the resulting interval after applying the abstract semantics of the operation
             switch (identifier_1.Identifier.getName(call.name)) {
                 case '+':
-                    return this.updateState(call.id, left.add(right));
+                    return this.currentState.set(call.id, left.add(right));
                 case '-':
-                    return this.updateState(call.id, left.subtract(right));
+                    return this.currentState.set(call.id, left.subtract(right));
             }
         }
     }
@@ -52,7 +57,7 @@ async function inferIntervals() {
     const dfg = (await analyzer.dataflow()).graph;
     const cfg = await analyzer.controlflow(undefined, cfg_kind_1.CfgKind.NoFunctionDefs);
     const ctx = analyzer.inspectContext();
-    const inference = new IntervalInferenceVisitor({ controlFlow: cfg, dfg: dfg, normalizedAst: ast, ctx: ctx }, interval_domain_1.IntervalDomain.top());
+    const inference = new IntervalInferenceVisitor({ controlFlow: cfg, dfg: dfg, normalizedAst: ast, ctx: ctx });
     inference.start();
     const result = inference.getEndState();
     return result.isValue() ? result.value.entries().toArray()
@@ -63,6 +68,21 @@ function nodeIdToSlicingCriterion(id, idMap) {
     const node = idMap.get(id);
     return `${node?.location?.[0]}@${node?.lexeme}`;
 }
+function multiValueExample() {
+    const domain = {
+        number: new interval_domain_1.IntervalDomain(interval_domain_1.IntervalTop),
+        string: new bounded_set_domain_1.BoundedSetDomain(lattice_1.Top)
+    };
+    const reduction = ({ number, string }) => {
+        if (number?.isBottom() || string?.isBottom()) {
+            return { number: domain.number.bottom(), string: domain.string.bottom() };
+        }
+        return { number, string };
+    };
+    const state = new multi_value_state_domain_1.MultiValueStateDomain(new Map(), domain, [reduction]);
+    state.setValue(0, 'number', new interval_domain_1.IntervalDomain([42, 42]));
+    state.setValue(1, 'string', new bounded_set_domain_1.BoundedSetDomain(new Set(['Hello world!'])));
+}
 class WikiAbsint extends doc_maker_1.DocMaker {
     constructor() {
         super('wiki/Abstract Interpretation.md', module.filename, 'abstract interpretation framework');
@@ -113,30 +133,34 @@ All boxes link to their respective implementation in the source code.
 ${(0, doc_code_1.codeBlock)('mermaid', ctx.mermaid(abstract_domain_1.AbstractDomain, { simplify: true, reverse: true }))}
 `.trim())}
 
+Multiple abstract domains can be combined using a ${ctx.link(multi_value_state_domain_1.MultiValueDomain)} (for example, to use an interval domain for numbers and bounded set domain for strings at the same time). A multi-value state domain (${ctx.link(multi_value_state_domain_1.MultiValueStateDomain)}) as state domain of a multi-value domain can be used to track the state of multiple value domains in a program. Additionally, is enables to define reductions on the multi-value domain to refine the inferred value for a value domain based on the other value domains in the multi-value domain. For example, the following example shows how a multi-value state domain can be defined to track numbers and strings at the same time with a simple reduction that sets both domains to bottom if one domain is bottom.
+
+${ctx.code(multiValueExample, { dropLinesStart: 1, dropLinesEnd: 1 })}
+
 ${(0, doc_structure_1.section)('Abstract Interpretation', 2, 'abstract-interpretation')}
 
 We perform abstract interpretation by forward-traversing the ${ctx.linkPage('wiki/Control Flow Graph', 'control flow graph')} of _flowR_ using an ${ctx.link(absint_visitor_1.AbstractInterpretationVisitor)}. For each visited control flow vertex, the visitor retrieves the current abstract state by joining the abstract states of the predecessors, applies the abstract semantics of the visited control flow vertex to the current state, and updates the abstract state of the currently visited vertex to the current state. The visitor already handles assignments and (delayed) widening at widening points. However, the visitor does not yet support interprocedural abstract interpretation.
 
-To implement a custom abstract interpretation analysis, we can just create a new class and extend the ${ctx.link(absint_visitor_1.AbstractInterpretationVisitor)}. The abstract interpretation visitor uses a ${ctx.link(state_abstract_domain_1.StateAbstractDomain)} to capture the current abstract state at each vertex in the control flow graph. Hence, the abstract interpretation visitor requires a value abstract domain \`Domain\` as type parameter to specify the state abstract domain. We can then extend the callback functions of the ${ctx.link(absint_visitor_1.AbstractInterpretationVisitor)} to implement the abstract semantics of expressions, such as ${ctx.link(`${semantic_cfg_guided_visitor_1.SemanticCfgGuidedVisitor.name}:::onNumberConstant`)}, ${ctx.link(`${absint_visitor_1.AbstractInterpretationVisitor.name}:::onFunctionCall`)}, and ${ctx.link(`${semantic_cfg_guided_visitor_1.SemanticCfgGuidedVisitor.name}:::onReplacementCall`)} (make sure to still call the respective super function). The abstract interpretation visitor provides the following functions to retrieve the currently inferred values:
+To implement a custom abstract interpretation analysis, we can just create a new class and extend the ${ctx.link(absint_visitor_1.AbstractInterpretationVisitor)}. The abstract interpretation visitor uses a \`StateDomain\` (e.g., a ${ctx.link(state_abstract_domain_1.StateAbstractDomain)}) to capture the current abstract state at each vertex in the control flow graph. We can then extend the callback functions of the ${ctx.link(absint_visitor_1.AbstractInterpretationVisitor)} to implement the abstract semantics of expressions, such as ${ctx.link(`${semantic_cfg_guided_visitor_1.SemanticCfgGuidedVisitor.name}:::onNumberConstant`)}, ${ctx.link(`${absint_visitor_1.AbstractInterpretationVisitor.name}:::onFunctionCall`)} and ${ctx.link(`${semantic_cfg_guided_visitor_1.SemanticCfgGuidedVisitor.name}:::onReplacementCall`)} (make sure to still call the respective super function). The abstract interpretation visitor provides the following functions to retrieve the currently inferred values:
 
  * ${ctx.linkM(absint_visitor_1.AbstractInterpretationVisitor, 'getAbstractValue')} to resolve the inferred abstract value for an AST node (this includes resolving symbols, pipes, and if expressions)
  * ${ctx.linkM(absint_visitor_1.AbstractInterpretationVisitor, 'getAbstractState')} to get the inferred abstract state at an AST node mapping AST nodes to abstract values
  * ${ctx.linkM(absint_visitor_1.AbstractInterpretationVisitor, 'getAbstractTrace')} to get the complete abstract trace mapping AST nodes to abstract states at the respective node
  * ${ctx.linkM(absint_visitor_1.AbstractInterpretationVisitor, 'getEndState')} to get the inferred abstract state at the end of the program (at the exit points of the control flow graph)
 
-For example, if we want to perform a (very basic) interval analysis using abstract interpretation in _flowR_, we can implement the following ${ctx.link(IntervalInferenceVisitor)} that extends ${ctx.link(absint_visitor_1.AbstractInterpretationVisitor)} using the ${ctx.link(interval_domain_1.IntervalDomain)}:
+For example, if we want to perform a (very basic) interval analysis using abstract interpretation in _flowR_, we can implement the following ${ctx.link(IntervalInferenceVisitor)} that extends ${ctx.link(absint_visitor_1.AbstractInterpretationVisitor)} using a ${ctx.link(state_abstract_domain_1.StateAbstractDomain)} for the ${ctx.link(interval_domain_1.IntervalDomain)}:
 
-${ctx.code(IntervalInferenceVisitor)}
+${ctx.code(inferIntervals, { dropLinesStart: 1, dropLinesEnd: 5 })}
 
-The interval inference visitor first overrides the ${ctx.link(`${semantic_cfg_guided_visitor_1.SemanticCfgGuidedVisitor.name}:::onNumberConstant`)} function to infer intervals for visited control flow vertices that represent numeric constants. For numeric constants, the resulting interval consists just of the number value of the constant. We then update the current abstract state of the visitor via ${ctx.linkM(absint_visitor_1.AbstractInterpretationVisitor, 'updateState', { hideClass: true })} by setting the inferred abstract value of the currently visited control flow vertex to the new interval.
+The interval inference visitor first overrides the ${ctx.link(`${semantic_cfg_guided_visitor_1.SemanticCfgGuidedVisitor.name}:::onNumberConstant`)} function to infer intervals for visited control flow vertices that represent numeric constants. For numeric constants, the resulting interval consists just of the number value of the constant. We then update the current abstract state of the visitor by setting the inferred abstract value of the currently visited control flow vertex to the new interval.
 
-In this simple example, we only want to support the addition and subtraction of numeric values. Therefore, we override the ${ctx.link(`${absint_visitor_1.AbstractInterpretationVisitor.name}:::onFunctionCall`)} function to apply the abstract semantics of additions and subtraction with resprect to the interval domain. For the addition and subtraction, we are only interested in function calls with exactly two non-empty arguments. We first resolve the currently inferred abstract value for the left and right operand of the function call. If we have no inferred value for one of the operands, this function call might not be a numeric function call and we ignore it. Otherwise, we check whether the function call represents an addition or subtraction and apply the abstract semantics of the operation to the left and right operand. We then again update the current abstract state of the visitor via ${ctx.linkM(absint_visitor_1.AbstractInterpretationVisitor, 'updateState', { hideClass: true })} by setting the inferred abstract value of the currently visited function call vertex to the abstract value resulting from applying the abstract semantics of the operation to the operands.
+In this simple example, we only want to support the addition and subtraction of numeric values. Therefore, we override the ${ctx.link(`${absint_visitor_1.AbstractInterpretationVisitor.name}:::onFunctionCall`)} function to apply the abstract semantics of additions and subtraction with resprect to the interval domain. For the addition and subtraction, we are only interested in function calls with exactly two non-empty arguments. We first resolve the currently inferred abstract value for the left and right operand of the function call. If we have not inferred a value for one of the operands, this function call might not be a numeric function call and we ignore it. Otherwise, we check whether the function call represents an addition or subtraction and apply the abstract semantics of the operation to the left and right operand. We then again update the current abstract state of the visitor by setting the inferred abstract value of the currently visited function call vertex to the abstract value resulting from applying the abstract semantics of the operation to the operands.
 
 If we now want to run the interval inference, we can write the following code:
 
 ${ctx.code(inferIntervals, { dropLinesStart: 1, dropLinesEnd: 5 })}
 
-We first need a ${ctx.linkPage('wiki/Analyzer', 'flowR analyzer')} (in this case, using the ${ctx.linkPage('wiki/Engines', 'tree-sitter engine')}). In this example, we want to analyze a small example code that assigns \`42\` to the variable \`x\`, randomly assigns \`6\` or \`12\` to the variable \`y\`, and assignes the sum of \`x\` and \`y\` to the variable \`z\`. For the abstract interpretation visitor, we need to retrieve the ${ctx.linkPage('wiki/Normalized AST', 'normalized AST')}, ${ctx.linkPage('wiki/Dataflow Graph', 'dataflow graph')}, ${ctx.linkPage('wiki/Control Flow Graph', 'control flow graph')}, context of the flowR anaylzer, and provide a value domain for the state domain. For performance reasons, we construct the control flow graph without simplification passes, data flow information, and function definitions. We then create a new ${ctx.link(IntervalInferenceVisitor)} using the control flow graph, dataflow graph, normalized AST, and analyzer context, and start the visitor using ${ctx.linkM(absint_visitor_1.AbstractInterpretationVisitor, 'start', { hideClass: true })}. After the visitor is finished, we retrieve the inferred abstract state at the end of the program using ${ctx.linkM(absint_visitor_1.AbstractInterpretationVisitor, 'getEndState', { hideClass: true })}.
+We first need a ${ctx.linkPage('wiki/Analyzer', 'flowR analyzer')} (in this case, using the ${ctx.linkPage('wiki/Engines', 'tree-sitter engine')}). In this example, we want to analyze a small example code that assigns \`42\` to the variable \`x\`, randomly assigns \`6\` or \`12\` to the variable \`y\`, and assignes the sum of \`x\` and \`y\` to the variable \`z\`. For the abstract interpretation visitor, we need to retrieve the ${ctx.linkPage('wiki/Normalized AST', 'normalized AST')}, ${ctx.linkPage('wiki/Dataflow Graph', 'dataflow graph')}, ${ctx.linkPage('wiki/Control Flow Graph', 'control flow graph')}, and context of the flowR anaylzer. For performance reasons, we construct the control flow graph without simplification passes, data flow information, and function definitions. We then create a new ${ctx.link(IntervalInferenceVisitor)} using the control flow graph, dataflow graph, normalized AST, and analyzer context, and start the visitor using ${ctx.linkM(absint_visitor_1.AbstractInterpretationVisitor, 'start', { hideClass: true })}. After the visitor is finished, we retrieve the inferred abstract state at the end of the program using ${ctx.linkM(absint_visitor_1.AbstractInterpretationVisitor, 'getEndState', { hideClass: true })}.
 
 If we now print the inferred abstract state at the end of the program, we get the following output:
 

package/documentation/wiki-analyzer.js

@@ -22,7 +22,6 @@ const flowr_analyzer_loading_order_context_1 = require("../project/context/flowr
 const flowr_analyzer_dependencies_context_1 = require("../project/context/flowr-analyzer-dependencies-context");
 const flowr_analyzer_cache_1 = require("../project/cache/flowr-analyzer-cache");
 const pipeline_executor_1 = require("../core/pipeline-executor");
-const flowr_analyzer_plugin_defaults_1 = require("../project/plugins/flowr-analyzer-plugin-defaults");
 const doc_maker_1 = require("./wiki-mk/doc-maker");
 const flowr_analyzer_rmd_file_plugin_1 = require("../project/plugins/file-plugins/notebooks/flowr-analyzer-rmd-file-plugin");
 const flowr_analyzer_plugin_1 = require("../project/plugins/flowr-analyzer-plugin");
@@ -219,7 +218,7 @@ This indicates three ways to add a new plugin:
 3. By providing a tuple of the plugin name and its constructor arguments (e.g., \`['file:rmd', [/.*.rmd/i]]\` for the ${ctx.link(flowr_analyzer_rmd_file_plugin_1.FlowrAnalyzerRmdFilePlugin)}).\\
    This will also use the ${ctx.link(plugin_registry_1.makePlugin)} function under the hood to create the plugin instance.
 
-Please note, that by passing \`false\` to the builder constructor, no default plugins (see ${ctx.link(flowr_analyzer_plugin_defaults_1.FlowrAnalyzerPluginDefaults)}) are registered (otherwise, all of the plugins in the example above would be registered by default).
+Please note, that by passing \`false\` to the builder constructor, no default plugins (see ${ctx.link('FlowrDefaultPlugins')}) are registered (otherwise, all of the plugins in the example above would be registered by default).
 If you want to unregister specific plugins, you can use the ${ctx.linkM(flowr_analyzer_builder_1.FlowrAnalyzerBuilder, 'unregisterPlugins')} method.
 
 ${(0, doc_structure_1.block)({
@@ -251,7 +250,7 @@ Plugins allow you to extend the capabilities of the analyzer in many different w
 For example, they can be used to support other file formats, or to provide new algorithms to determine the loading order of files in a project.
 All plugins have to extend the ${ctx.link(flowr_analyzer_plugin_1.FlowrAnalyzerPlugin)} base class and specify their ${ctx.link('PluginType')}.
 During the analysis, the analyzer will apply all registered plugins of the different types at the appropriate stages of the analysis.
-If you just want to _use_ these plugins, you can usually ignore their [type](#plugin-types) and just register them with the builder as described 
+If you just want to _use_ these plugins, you can usually ignore their [type](#plugin-types) and just register them with the builder as described
 in the [Builder Configuration](#builder-configuration) section above.
 However, if you want to _create_ new plugins, you should be aware of the different plugin types and when they are applied during the analysis.
 
@@ -285,7 +284,7 @@ ${(0, doc_structure_1.section)('Project Discovery', 4)}
 
 These plugins trigger when confronted with a project analysis request (see, ${ctx.link('RProjectAnalysisRequest')}).
 Their job is to identify the files that belong to the project and add them to the analysis.
-flowR provides the ${ctx.link(flowr_analyzer_project_discovery_plugin_1.FlowrAnalyzerProjectDiscoveryPlugin)} with a 
+flowR provides the ${ctx.link(flowr_analyzer_project_discovery_plugin_1.FlowrAnalyzerProjectDiscoveryPlugin)} with a
 ${ctx.link(flowr_analyzer_project_discovery_plugin_1.FlowrAnalyzerProjectDiscoveryPlugin.defaultPlugin.name)} as the default implementation that simply collects all R source files in the given folder.
 
 Please note that all project discovery plugins should conform to the ${ctx.link(flowr_analyzer_project_discovery_plugin_1.FlowrAnalyzerProjectDiscoveryPlugin)} base class.

package/documentation/wiki-interface.js

@@ -20,6 +20,7 @@ const doc_structure_1 = require("./doc-util/doc-structure");
 const doc_maker_1 = require("./wiki-mk/doc-maker");
 const doc_writing_code_1 = require("./data/interface/doc-writing-code");
 const built_in_proc_name_1 = require("../dataflow/environments/built-in-proc-name");
+const flowr_analyzer_1 = require("../project/flowr-analyzer");
 async function explainServer(parser) {
     (0, doc_data_server_messages_1.documentAllServerMessages)();
     return `
@@ -42,7 +43,7 @@ ${await (0, doc_server_message_1.printServerMessages)(parser)}
 ### 📡 Ways of Connecting
 
 If you are interested in clients that communicate with _flowR_, please check out the [R adapter](${doc_files_1.FlowrGithubBaseRef}/flowr-r-adapter)
-as well as the [Visual Studio Code extension](${doc_files_1.FlowrGithubBaseRef}/vscode-flowr). 
+as well as the [Visual Studio Code extension](${doc_files_1.FlowrGithubBaseRef}/vscode-flowr).
 
 <ol>
 
@@ -99,9 +100,9 @@ async function explainRepl(parser, ctx) {
 > To execute arbitrary R commands with a repl request, _flowR_ has to be started explicitly with ${ctx.cliOption('flowr', 'r-session-access')}.
 > Please be aware that this introduces a security risk and note that this relies on the ${ctx.linkPage('wiki/Engines', '`r-shell` engine')} .
 
-Although primarily meant for users to explore, 
-there is nothing which forbids simply calling _flowR_ as a subprocess to use standard-in, -output, and -error 
-for communication (although you can access the REPL using the server as well, 
+Although primarily meant for users to explore,
+there is nothing which forbids simply calling _flowR_ as a subprocess to use standard-in, -output, and -error
+for communication (although you can access the REPL using the server as well,
 with the [REPL Request](#message-request-repl-execution) message).
 
 The read-eval-print loop&nbsp;(REPL) works relatively simple.
@@ -111,7 +112,7 @@ The best command to get started with the REPL is ${ctx.replCmd('help')}.
 Besides, you can leave the REPL either with the command ${ctx.replCmd('quit')} or by pressing <kbd>Ctrl</kbd>+<kbd>C</kbd> twice.
 When writing a *command*, you may press <kbd>Tab</kbd> to get a list of completions, if available.
 Multiple commands can be entered in a single line by separating them with a semicolon (\`;\`), e.g. \`:parse "x<-2"; :df*\`.
-If a command is given without R code, the REPL will re-use R code given in a previous command. 
+If a command is given without R code, the REPL will re-use R code given in a previous command.
 The prior example will hence return first the parsed AST of the program and then the dataflow graph for \`"x <- 2"\`.
 
 > [!NOTE]
@@ -144,7 +145,7 @@ can be used to also modify the currently active configuration of _flowR_ within
 
 ### Example: Retrieving the Dataflow Graph
 
-To retrieve a URL to the [mermaid](https://mermaid.js.org/) diagram of the dataflow of a given expression, 
+To retrieve a URL to the [mermaid](https://mermaid.js.org/) diagram of the dataflow of a given expression,
 use ${ctx.replCmd('dataflow*')} (or ${ctx.replCmd('dataflow')} to get the mermaid code in the cli):
 
 ${await (0, doc_repl_1.documentReplSession)(parser, [{
@@ -163,8 +164,8 @@ For the slicing with ${ctx.replCmd('slicer')}, you have access to the same [magi
 
 ### Example: Interfacing with the File System
 
-Many commands that allow for an R-expression (like ${ctx.replCmd('dataflow*')}) allow for a file as well 
-if the argument starts with \`${retriever_1.fileProtocol}\`. 
+Many commands that allow for an R-expression (like ${ctx.replCmd('dataflow*')}) allow for a file as well
+if the argument starts with \`${retriever_1.fileProtocol}\`.
 If you are working from the root directory of the _flowR_ repository, the following gives you the parsed AST of the example file using the ${ctx.replCmd('parse')} command:
 
 ${await (0, doc_repl_1.documentReplSession)(parser, [{
@@ -179,7 +180,7 @@ ${(0, doc_code_1.codeBlock)('r', (0, doc_files_1.getFileContentFromRoot)('test/t
 
 </details>
 
-As _flowR_ directly transforms this AST the output focuses on being human-readable instead of being machine-readable. 
+As _flowR_ directly transforms this AST the output focuses on being human-readable instead of being machine-readable.
 		`
         }])}
 
@@ -203,8 +204,8 @@ For more information on the available queries, please check out the ${ctx.linkPa
 function explainConfigFile(ctx) {
     return `
 
-When running _flowR_, you may want to specify some behaviors with a dedicated configuration file. 
-By default, flowR looks for a file named \`${flowr_main_options_1.defaultConfigFile}\` in the current working directory (or any higher directory). 
+When running _flowR_, you may want to specify some behaviors with a dedicated configuration file.
+By default, flowR looks for a file named \`${flowr_main_options_1.defaultConfigFile}\` in the current working directory (or any higher directory).
 You can also specify a different file with ${(0, doc_cli_option_1.getCliLongOptionOf)('flowr', 'config-file')} or pass the configuration inline using ${(0, doc_cli_option_1.getCliLongOptionOf)('flowr', 'config-json')}.
 To inspect the current configuration, you can run flowr with the ${(0, doc_cli_option_1.getCliLongOptionOf)('flowr', 'verbose')} flag, or use the \`config\` [Query](${doc_files_1.FlowrWikiBaseRef}/Query%20API).
 Within the REPL this works by running the following:
@@ -216,13 +217,15 @@ ${ctx.linkO(config_1.FlowrConfig, 'amend')}.
 The following summarizes the configuration options:
 
 - \`ignoreSourceCalls\`: If set to \`true\`, _flowR_ will ignore source calls when analyzing the code, i.e., ignoring the inclusion of other files.
-- \`semantics\`: allows to configure the way _flowR_ handles R, although we currently only support \`semantics/environment/overwriteBuiltIns\`. 
-  You may use this to overwrite _flowR_'s handling of built-in function and even completely clear the preset definitions shipped with flowR. 
+- \`semantics\`: allows to configure the way _flowR_ handles R, although we currently only support \`semantics/environment/overwriteBuiltIns\`.
+  You may use this to overwrite _flowR_'s handling of built-in function and even completely clear the preset definitions shipped with flowR.
   See [Configure BuiltIn Semantics](#configure-builtin-semantics) for more information.
 - \`solver\`: allows to configure how _flowR_ resolves variables and their values (currently we support: ${Object.values(config_1.VariableResolve).map(v => `\`${v}\``).join(', ')}), as well as if pointer analysis should be active.
 - \`engines\`: allows to configure the engines used by _flowR_ to interact with R code. See the [Engines wiki page](${doc_files_1.FlowrWikiBaseRef}/Engines) for more information.
 - \`defaultEngine\`: allows to specify the default engine to use for interacting with R code. If not set, an arbitrary engine from the specified list will be used.
 - \`abstractInterpretation\`: allows to configure how _flowR_ performs abstract interpretation, although we currently only support data frame shape inference through abstract interpretation.
+- \`defaultPlugins\`: allows to configure which plugins to load by default when creating a new ${ctx.link(flowr_analyzer_1.FlowrAnalyzer)} instance.
+- \`repl.plugins\`: allows to configure which plugins to load in the _flowR_ REPL. Use \`flowr:default\` to reference the plugins specified by \`defaultPlugins\`.
 
 So you can configure _flowR_ by adding a file like the following:
 
@@ -241,9 +244,11 @@ ${(0, doc_code_1.codeBlock)('json', JSON.stringify({
                 }
             }
         },
+        defaultPlugins: ['file:description', 'versions:description'],
         repl: {
             quickStats: false,
-            dfProcessorHeat: false
+            dfProcessorHeat: false,
+            plugins: ['flowr:default']
         },
         project: {
             resolveUnknownPathsOnDisk: true
@@ -277,9 +282,9 @@ ${(0, doc_code_1.codeBlock)('json', JSON.stringify({
 
 </details>
 
-<details> 
+<details>
 <a id='configure-builtin-semantics'></a>
-<summary>Configure Built-In Semantics</summary> 
+<summary>Configure Built-In Semantics</summary>
 
 
 \`semantics/environment/overwriteBuiltins\` accepts two keys:

package/documentation/wiki-linter.js

@@ -124,7 +124,7 @@ df[6, "value"]
     rule(knownParser, 'useless-loop', 'UselessLoopConfig', 'USELESS_LOOP', 'lint-useless-loop', 'for(i in c(1)) { print(i) }', tagTypes);
     rule(knownParser, 'stop-call', 'StopWithCallConfig', 'STOP_WITH_CALL_ARG', 'lint-stop-call', 'stop(42)', tagTypes);
     rule(knownParser, 'roxygen-arguments', 'RoxygenArgsConfig', 'ROXYGEN_ARGS', 'lint-roxygen-arguments', '#\' A function with two parameters, but only only one documented\n#\' @param a A variable\nf = function(a, b){return a;}', tagTypes);
-    rule(knownParser, 'problematic-eval', 'ProblematicEvalConfig', 'PROBLEMATIC_EVAL', 'lint-problematic-eval', `
+    rule(knownParser, 'problematic-inputs', 'ProblematicInputsConfig', 'PROBLEMATIC_INPUTS', 'lint-problematic-inputs', `
 function(x) {
 	eval(x)
 }

package/linter/linter-rules.d.ts

@@ -78,7 +78,7 @@ export declare const LintingRules: {
                     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 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", "rbeta", "rf", "rhyper", "rweibull", "rt", "rvonmises", "rwilcox", "rxor", "rhyper", "rmvnorm", "rsignrank", "randomForest", "permuted", "permute", "shuffle", "shuffleSet", "data_shuffle", "sample_frac", "sample_n", "slice_sample"];
             };
             readonly tags: readonly [import("./linter-tags").LintingRuleTag.Robustness, import("./linter-tags").LintingRuleTag.Reproducibility];
             readonly certainty: import("./linter-format").LintingRuleCertainty.BestEffort;
@@ -196,7 +196,7 @@ export declare const LintingRules: {
             readonly certainty: import("./linter-format").LintingRuleCertainty.BestEffort;
             readonly description: "Marks network functions that execute network operations, such as downloading files or making HTTP requests.";
             readonly defaultConfig: {
-                readonly fns: readonly ["read.table", "read.csv", "read.csv2", "read.delim", "read.delim2", "readRDS", "download.file", "url", "GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "content", "handle", "get_callback", "VERB", "fread", "gzcon", "readlines", "source", "load", "curl_download", "curl_fetch_memory", "getURL", "getForm", "read_html", "html_nodes", "html_text", "fromJSON", "read.xlsx", "drive_download", "drive_get", "s3read_using", "s3write_using", "storage_download", "AnnotationHub", "ExperimentHub"];
+                readonly fns: readonly ["read.table", "read.csv", "read.csv2", "read.delim", "read.delim2", "readRDS", "download.file", "url", "GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "content", "handle", "get_callback", "VERB", "fread", "gzcon", "readlines", "readLines", "source", "load", "curl_download", "curl_fetch_memory", "getURL", "getForm", "read_html", "read_xml", "html_nodes", "html_text", "fromJSON", "read.xlsx", "drive_download", "drive_get", "s3read_using", "s3write_using", "storage_download", "AnnotationHub", "ExperimentHub", "scan", "socketConnection", "request", "curl"];
                 readonly onlyTriggerWithArgument: RegExp;
             };
         };
@@ -281,28 +281,28 @@ export declare const LintingRules: {
             };
         };
     };
-    readonly 'problematic-eval': {
-        readonly createSearch: (config: import("./rules/problematic-eval").ProblematicEvalConfig) => import("../search/flowr-search-builder").FlowrSearchBuilder<"from-query", [], 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: import("./rules/problematic-eval").ProblematicEvalConfig, data: {
+    readonly 'problematic-inputs': {
+        readonly createSearch: (config: import("./rules/problematic-inputs").ProblematicInputsConfig) => import("../search/flowr-search-builder").FlowrSearchBuilder<"from-query", [], 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: import("./rules/problematic-inputs").ProblematicInputsConfig, data: {
             normalize: import("../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
             dataflow: import("../dataflow/info").DataflowInformation;
             cfg: import("../control-flow/control-flow-graph").ControlFlowInformation;
             analyzer: import("../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider;
         }) => Promise<{
-            results: import("./rules/problematic-eval").ProblematicEvalResult[];
-            ".meta": import("./rules/problematic-eval").ProblematicEvalMetadata;
+            results: import("./rules/problematic-inputs").ProblematicInputsResult[];
+            '.meta': {};
         }>;
         readonly prettyPrint: {
-            readonly query: (result: import("./rules/problematic-eval").ProblematicEvalResult) => string;
-            readonly full: (result: import("./rules/problematic-eval").ProblematicEvalResult) => string;
+            readonly query: (result: import("./rules/problematic-inputs").ProblematicInputsResult) => string;
+            readonly full: (result: import("./rules/problematic-inputs").ProblematicInputsResult) => string;
         };
         readonly info: {
-            readonly name: "Problematic eval";
-            readonly description: "Detects uses of eval-like functions whose inputs are not statically constant. Prints the computed input-sources for the eval and flags usages that depend on non-constant/trusted inputs.";
+            readonly name: "Problematic inputs";
+            readonly description: "Detects uses of configured dynamic calls (e.g. eval, system) whose inputs are not statically constant. Prints the computed input-sources for the call and flags usages that depend on non-constant/trusted inputs.";
             readonly tags: readonly [import("./linter-tags").LintingRuleTag.Security, import("./linter-tags").LintingRuleTag.Smell, import("./linter-tags").LintingRuleTag.Readability, import("./linter-tags").LintingRuleTag.Performance];
             readonly certainty: import("./linter-format").LintingRuleCertainty.BestEffort;
             readonly defaultConfig: {
-                readonly considerAsEval: "^eval$";
+                readonly consider: readonly ["^eval$", "^system$", "^system2$", "^shell$"];
             };
         };
     };

package/linter/linter-rules.js

@@ -13,7 +13,7 @@ const useless_loop_1 = require("./rules/useless-loop");
 const network_functions_1 = require("./rules/network-functions");
 const stop_with_call_arg_1 = require("./rules/stop-with-call-arg");
 const roxygen_arguments_1 = require("./rules/roxygen-arguments");
-const problematic_eval_1 = require("./rules/problematic-eval");
+const problematic_inputs_1 = require("./rules/problematic-inputs");
 /**
  * The registry of currently supported linting rules.
  * A linting rule can be executed on a dataflow pipeline result using {@link executeLintingRule}.
@@ -29,7 +29,7 @@ exports.LintingRules = {
     'dataframe-access-validation': dataframe_access_validation_1.DATA_FRAME_ACCESS_VALIDATION,
     'dead-code': dead_code_1.DEAD_CODE,
     'useless-loop': useless_loop_1.USELESS_LOOP,
-    'problematic-eval': problematic_eval_1.PROBLEMATIC_EVAL,
+    'problematic-inputs': problematic_inputs_1.PROBLEMATIC_INPUTS,
     'stop-call': stop_with_call_arg_1.STOP_WITH_CALL_ARG,
     'roxygen-arguments': roxygen_arguments_1.ROXYGEN_ARGS
 };

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

@@ -31,7 +31,7 @@ export declare const NETWORK_FUNCTIONS: {
         readonly certainty: LintingRuleCertainty.BestEffort;
         readonly description: "Marks network functions that execute network operations, such as downloading files or making HTTP requests.";
         readonly defaultConfig: {
-            readonly fns: readonly ["read.table", "read.csv", "read.csv2", "read.delim", "read.delim2", "readRDS", "download.file", "url", "GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "content", "handle", "get_callback", "VERB", "fread", "gzcon", "readlines", "source", "load", "curl_download", "curl_fetch_memory", "getURL", "getForm", "read_html", "html_nodes", "html_text", "fromJSON", "read.xlsx", "drive_download", "drive_get", "s3read_using", "s3write_using", "storage_download", "AnnotationHub", "ExperimentHub"];
+            readonly fns: readonly ["read.table", "read.csv", "read.csv2", "read.delim", "read.delim2", "readRDS", "download.file", "url", "GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "content", "handle", "get_callback", "VERB", "fread", "gzcon", "readlines", "readLines", "source", "load", "curl_download", "curl_fetch_memory", "getURL", "getForm", "read_html", "read_xml", "html_nodes", "html_text", "fromJSON", "read.xlsx", "drive_download", "drive_get", "s3read_using", "s3write_using", "storage_download", "AnnotationHub", "ExperimentHub", "scan", "socketConnection", "request", "curl"];
             readonly onlyTriggerWithArgument: RegExp;
         };
     };

package/linter/rules/network-functions.js

@@ -29,8 +29,14 @@ exports.NETWORK_FUNCTIONS = {
         certainty: linter_format_1.LintingRuleCertainty.BestEffort,
         description: 'Marks network functions that execute network operations, such as downloading files or making HTTP requests.',
         defaultConfig: {
-            fns: ['read.table', 'read.csv', 'read.csv2', 'read.delim', 'read.delim2', 'readRDS', 'download.file', 'url', 'GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'content', 'handle', 'get_callback', 'VERB', 'fread', 'gzcon', 'readlines', 'source', 'load', 'curl_download', 'curl_fetch_memory', 'getURL', 'getForm', 'read_html', 'html_nodes', 'html_text', 'fromJSON', 'read.xlsx', 'drive_download', 'drive_get', 's3read_using', 's3write_using', 'storage_download', 'AnnotationHub', 'ExperimentHub'],
-            onlyTriggerWithArgument: /^(https?|ftps?|file):\/\//
+            fns: [
+                'read.table', 'read.csv', 'read.csv2', 'read.delim', 'read.delim2', 'readRDS', 'download.file', 'url', 'GET', 'POST', 'PUT',
+                'DELETE', 'PATCH', 'HEAD', 'content', 'handle', 'get_callback', 'VERB', 'fread', 'gzcon', 'readlines', 'readLines', 'source', 'load', 'curl_download',
+                'curl_fetch_memory', 'getURL', 'getForm', 'read_html', 'read_xml', 'html_nodes', 'html_text', 'fromJSON', 'read.xlsx', 'drive_download', 'drive_get',
+                's3read_using', 's3write_using', 'storage_download', 'AnnotationHub', 'ExperimentHub', 'scan',
+                'socketConnection', 'request', 'curl'
+            ],
+            onlyTriggerWithArgument: /^(https?|ftps?):\/\//
         }
     }
 };

package/linter/rules/problematic-inputs.d.ts

@@ -0,0 +1,43 @@
+import { type LintingResult, LintingRuleCertainty } from '../linter-format';
+import type { MergeableRecord } from '../../util/objects';
+import { SourceLocation } from '../../util/range';
+import { LintingRuleTag } from '../linter-tags';
+import type { InputClassifierConfig, InputSources } from '../../queries/catalog/input-sources-query/simple-input-classifier';
+/**
+ * Describes a linting result for a problematic eval usage, including the location of the eval call and the computed input sources that lead to it.
+ */
+export interface ProblematicInputsResult extends LintingResult {
+    name: string;
+    loc: SourceLocation;
+    sources: InputSources;
+}
+export interface ProblematicInputsConfig extends MergeableRecord {
+    consider?: string | string[];
+    inputFns?: InputClassifierConfig;
+}
+export type ProblematicInputsMetadata = MergeableRecord;
+export declare const PROBLEMATIC_INPUTS: {
+    readonly createSearch: (config: ProblematicInputsConfig) => import("../../search/flowr-search-builder").FlowrSearchBuilder<"from-query", [], 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: ProblematicInputsConfig, data: {
+        normalize: import("../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+        dataflow: import("../../dataflow/info").DataflowInformation;
+        cfg: import("../../control-flow/control-flow-graph").ControlFlowInformation;
+        analyzer: import("../../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider;
+    }) => Promise<{
+        results: ProblematicInputsResult[];
+        '.meta': {};
+    }>;
+    readonly prettyPrint: {
+        readonly query: (result: ProblematicInputsResult) => string;
+        readonly full: (result: ProblematicInputsResult) => string;
+    };
+    readonly info: {
+        readonly name: "Problematic inputs";
+        readonly description: "Detects uses of configured dynamic calls (e.g. eval, system) whose inputs are not statically constant. Prints the computed input-sources for the call and flags usages that depend on non-constant/trusted inputs.";
+        readonly tags: readonly [LintingRuleTag.Security, LintingRuleTag.Smell, LintingRuleTag.Readability, LintingRuleTag.Performance];
+        readonly certainty: LintingRuleCertainty.BestEffort;
+        readonly defaultConfig: {
+            readonly consider: readonly ["^eval$", "^system$", "^system2$", "^shell$"];
+        };
+    };
+};

package/linter/rules/problematic-inputs.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROBLEMATIC_INPUTS = 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 linter_tags_1 = require("../linter-tags");
+const simple_input_classifier_1 = require("../../queries/catalog/input-sources-query/simple-input-classifier");
+const parse_1 = require("../../slicing/criterion/parse");
+const defaultConsider = ['^eval$', '^system$', '^system2$', '^shell$'];
+function normalizeConsider(cfg) {
+    if (cfg?.consider === undefined) {
+        return Array.from(defaultConsider, s => new RegExp(s));
+    }
+    if (Array.isArray(cfg.consider)) {
+        const arr = cfg.consider.length === 0 ? Array.from(defaultConsider) : cfg.consider;
+        // deduplicate while preserving order
+        return Array.from(new Set(arr), s => new RegExp(s));
+    }
+    return [new RegExp(cfg.consider)];
+}
+/**
+ * Format a list of input sources either as a single-line string (inline) or a block.
+ * - inline: returns a semicolon-separated single-line summary
+ * - block: returns an array of lines (to be joined with newlines by the caller)
+ */
+function formatInputSources(inputs, inline = true) {
+    if (!inputs || inputs.length === 0) {
+        return inline ? '' : [];
+    }
+    const formatOne = (s, inlineMode) => {
+        const typeStr = '[' + s.types.join(',') + ']';
+        const cdsStr = s.cds ? ', cds: [' + s.cds.join(',') + ']' : '';
+        return inlineMode
+            ? `${s.id} (type: ${typeStr}, trace: ${s.trace}${cdsStr})`
+            : `- ${s.id}: type=${typeStr}, trace=${s.trace}${cdsStr}`;
+    };
+    if (inline) {
+        return inputs.map(s => formatOne(s, true)).join('; ');
+    }
+    return inputs.map(s => formatOne(s, false));
+}
+// small helpers to keep checks readable
+function hasUnknownSource(sources) {
+    return sources.some(s => s.types.includes(simple_input_classifier_1.InputType.Unknown));
+}
+function isProblematicForAllowed(sources, allowed) {
+    return sources.some(s => s.types.some(t => !allowed.includes(t)));
+}
+exports.PROBLEMATIC_INPUTS = {
+    createSearch: config => {
+        const considerArr = normalizeConsider(config);
+        const queries = considerArr.map((name, i) => ({
+            type: 'call-context',
+            callName: name,
+            callNameExact: false,
+            subkind: `fn-${i}`
+        }));
+        return flowr_search_builder_1.Q.fromQuery(...queries);
+    },
+    processSearchResult: async (elements, config, data) => {
+        const results = [];
+        const defaultAccept = [simple_input_classifier_1.InputType.Constant, simple_input_classifier_1.InputType.DerivedConstant];
+        for (const element of elements.getElements()) {
+            const nid = element.node.info.id;
+            const criterion = parse_1.SlicingCriterion.fromId(nid);
+            const q = { type: 'input-sources', criterion, config: config.inputFns };
+            const all = await data.analyzer.query([q]);
+            const inputSourcesResult = all['input-sources'];
+            const sources = inputSourcesResult?.results?.[criterion] ?? [];
+            if (isProblematicForAllowed(sources, defaultAccept)) {
+                const certainty = hasUnknownSource(sources) ? linter_format_1.LintingResultCertainty.Uncertain : linter_format_1.LintingResultCertainty.Certain;
+                results.push({
+                    involvedId: nid,
+                    certainty,
+                    loc: range_1.SourceLocation.fromNode(element.node) ?? range_1.SourceLocation.invalid(),
+                    name: element.node.lexeme ?? '',
+                    sources
+                });
+            }
+        }
+        return {
+            results,
+            '.meta': {}
+        };
+    },
+    /* helper to format input sources for pretty printing */
+    prettyPrint: {
+        [linter_format_1.LintingPrettyPrintContext.Query]: result => {
+            const inputs = result.sources ?? [];
+            const srcStr = formatInputSources(inputs, true);
+            return 'Use of configured dynamic call at ' + range_1.SourceLocation.format(result.loc) + (srcStr ? '; inputs: ' + srcStr : '');
+        },
+        [linter_format_1.LintingPrettyPrintContext.Full]: result => {
+            const inputs = result.sources ?? [];
+            const srcLines = formatInputSources(inputs, false);
+            return 'Use of configured dynamic call at ' + range_1.SourceLocation.format(result.loc) + ' is potentially problematic' + (srcLines.length ? '\nInputs:\n' + srcLines.join('\n') : '');
+        }
+    },
+    info: {
+        name: 'Problematic inputs',
+        description: 'Detects uses of configured dynamic calls (e.g. eval, system) whose inputs are not statically constant. Prints the computed input-sources for the call and flags usages that depend on non-constant/trusted inputs.',
+        tags: [linter_tags_1.LintingRuleTag.Security, linter_tags_1.LintingRuleTag.Smell, linter_tags_1.LintingRuleTag.Readability, linter_tags_1.LintingRuleTag.Performance],
+        certainty: linter_format_1.LintingRuleCertainty.BestEffort,
+        defaultConfig: {
+            consider: defaultConsider
+        }
+    }
+};
+//# sourceMappingURL=problematic-inputs.js.map

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

@@ -54,7 +54,7 @@ export declare const SEEDED_RANDOMNESS: {
                 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 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", "rbeta", "rf", "rhyper", "rweibull", "rt", "rvonmises", "rwilcox", "rxor", "rhyper", "rmvnorm", "rsignrank", "randomForest", "permuted", "permute", "shuffle", "shuffleSet", "data_shuffle", "sample_frac", "sample_n", "slice_sample"];
         };
         readonly tags: readonly [LintingRuleTag.Robustness, LintingRuleTag.Reproducibility];
         readonly certainty: LintingRuleCertainty.BestEffort;

package/linter/rules/seeded-randomness.js

@@ -126,7 +126,14 @@ exports.SEEDED_RANDOMNESS = {
     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'],
+            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',
+                'rbeta', 'rf', 'rhyper', 'rweibull', 'rt', 'rvonmises', 'rwilcox', 'rxor', 'rhyper', 'rmvnorm',
+                'rsignrank', 'randomForest',
+                'permuted', 'permute', 'shuffle', 'shuffleSet', 'data_shuffle', 'sample_frac', 'sample_n', 'slice_sample',
+            ],
         },
         tags: [linter_tags_1.LintingRuleTag.Robustness, linter_tags_1.LintingRuleTag.Reproducibility],
         // only finds proper randomness producers and consumers due to its config, but will not find all producers/consumers since not all existing deprecated functions will be in the config