@eagleoutice/flowr 2.9.12 → 2.9.14

package/documentation/wiki-analyzer.js

@@ -29,6 +29,7 @@ const flowr_analyzer_plugin_1 = require("../project/plugins/flowr-analyzer-plugi
 const flowr_analyzer_environment_context_1 = require("../project/context/flowr-analyzer-environment-context");
 const flowr_analyzer_functions_context_1 = require("../project/context/flowr-analyzer-functions-context");
 const flowr_analyzer_meta_context_1 = require("../project/context/flowr-analyzer-meta-context");
+const config_1 = require("../config");
 async function analyzerQuickExample() {
     const analyzer = await new flowr_analyzer_builder_1.FlowrAnalyzerBuilder()
         .setEngine('tree-sitter')
@@ -172,23 +173,24 @@ The following sections highlight some of the most important configuration option
 ${(0, doc_structure_1.section)('Configuring flowR', 3)}
 
 You can fundamentally change the behavior of flowR using the [config file](${doc_files_1.FlowrWikiBaseRef}/Interface#configuring-flowr),
-embedded in the interface ${ctx.link('FlowrConfigOptions')}.
+embedded in the interface ${ctx.link(config_1.FlowrConfig)}.
 With the builder you can either provide a complete configuration or amend the default configuration using:
 
 * ${ctx.linkM(flowr_analyzer_builder_1.FlowrAnalyzerBuilder, 'setConfig')} to set a complete configuration
+* ${ctx.linkM(flowr_analyzer_builder_1.FlowrAnalyzerBuilder, 'configure')} to set the value of a specific key in the config
 * ${ctx.linkM(flowr_analyzer_builder_1.FlowrAnalyzerBuilder, 'amendConfig')} to amend the default configuration
 
-By default, the builder uses flowR's standard configuration obtained with ${ctx.link('defaultConfigOptions')}.
+By default, the builder uses flowR's standard configuration obtained with ${ctx.linkO(config_1.FlowrConfig, 'default')}.
 
 ${(0, doc_structure_1.block)({
             type: 'NOTE',
-            content: `During the analysis with the ${ctx.link(flowr_analyzer_1.FlowrAnalyzer.name)}, you can also access the configuration with
+            content: `During the analysis with the ${ctx.link(flowr_analyzer_1.FlowrAnalyzer)}, you can also access the configuration with
 		 the ${ctx.link(flowr_analyzer_context_1.FlowrAnalyzerContext)}.`
         })}
 
 ${(0, doc_structure_1.section)('Configuring the Engine', 3)}
 
-FlowR supports multiple [engines](${doc_files_1.FlowrWikiBaseRef}/Engines) for parsing and analyzing R code.
+FlowR supports multiple ${ctx.linkPage('wiki/Engines', 'engines')} for parsing and analyzing R code.
 With the builder, you can select the engine to use with:
 
 * ${ctx.linkM(flowr_analyzer_builder_1.FlowrAnalyzerBuilder, 'setEngine')} to set the desired engine.
@@ -292,7 +294,7 @@ ${(0, doc_structure_1.section)('File Loading', 4)}
 
 These plugins register for every file encountered by the [files context](#Files_Context) and determine whether and _how_ they can process the file.
 They are responsible for transforming the raw file content into a representation that flowR can work with during the analysis.
-For example, the ${ctx.link(flowr_analyzer_description_file_plugin_1.FlowrAnalyzerDescriptionFilePlugin.name)} adds support for R \`DESCRIPTION\` files by parsing their content into key-value pairs.
+For example, the ${ctx.link(flowr_analyzer_description_file_plugin_1.FlowrAnalyzerDescriptionFilePlugin)} adds support for R \`DESCRIPTION\` files by parsing their content into key-value pairs.
 These can then be used by other plugins, e.g. the ${ctx.link(flowr_analyzer_package_versions_description_file_plugin_1.FlowrAnalyzerPackageVersionsDescriptionFilePlugin)} that extracts package version information from these files.
 
 If multiple file plugins could apply (${ctx.link('DefaultFlowrAnalyzerFilePlugin::' + flowr_analyzer_file_plugin_1.FlowrAnalyzerFilePlugin.defaultPlugin().applies.name)}) to the same file,

package/documentation/wiki-core.js

@@ -45,11 +45,10 @@ const doc_structure_1 = require("./doc-util/doc-structure");
 const shell_1 = require("../r-bridge/shell");
 const log_1 = require("../../test/functionality/_helper/log");
 const log_2 = require("../util/log");
+const model_1 = require("../r-bridge/lang-4.x/ast/model/model");
 async function makeAnalyzerExample() {
     const analyzer = await new flowr_analyzer_builder_1.FlowrAnalyzerBuilder()
-        .amendConfig(c => {
-        c.ignoreSourceCalls = true;
-    })
+        .configure('ignoreSourceCalls', true)
         .setEngine('tree-sitter')
         .build();
     analyzer.addRequest('x <- 1; y <- x; print(y);');
@@ -310,7 +309,7 @@ If you are interested in the raw token types that we may encounter, have a look
 The normalization function ${ctx.link(parser_2.normalize)} takes the output from the previous steps and uses the ${ctx.link(format_1.prepareParsedData)} and 
 ${ctx.link(format_1.convertPreparedParsedData)} functions to first transform the serialized parsing output to an object. 
 Next, ${ctx.link(normalize_root_1.normalizeRootObjToAst)} transforms this object to a normalized AST and ${ctx.link(decorate_1.decorateAst)} adds additional information to the AST (like roles, ids, depth, etc.).
-While looking at the mermaid visualization of such an AST is nice and usually sufficient, looking at the objects themselves shows you the full range of information the AST provides (all encompassed within the ${ctx.link('RNode')} type).
+While looking at the mermaid visualization of such an AST is nice and usually sufficient, looking at the objects themselves shows you the full range of information the AST provides (all encompassed within the ${ctx.link(model_1.RNode)} type).
 
 Let's have a look at the normalized AST for the sample code \`${sampleCode}\` (please refer to the [normalized AST](${doc_files_1.FlowrWikiBaseRef}/Normalized-AST) wiki page for more information):
 
@@ -360,7 +359,7 @@ We use the ${ctx.link(extractor_1.produceDataFlowGraph)} function as an entry po
 The function is mainly backed by its ${ctx.link('processors')} object which maps each type in the normalized AST to an appropriate handler ("fold-function").
 
 To understand these handlers, let's start with the simplest one, ${ctx.link(process_uninteresting_leaf_1.processUninterestingLeaf)} signals that 
-we do not care about this node and just produce an empty dataflow information (using ${ctx.link(info_1.initializeCleanDataflowInformation)}). 
+we do not care about this node and just produce an empty dataflow information (using ${ctx.linkO(info_1.DataflowInformation, 'initialize')}). 
 Looking at the function showcases the general structure of a processor:
 
 ${ctx.hierarchy(process_uninteresting_leaf_1.processUninterestingLeaf, { maxDepth: 2, openTop: true })}
@@ -386,7 +385,7 @@ ${ctx.hierarchy(process_value_1.processValue, { maxDepth: 2, openTop: true })}
 
 Please note, that we add the [value vertex](${doc_files_1.FlowrWikiBaseRef}/Dataflow-Graph#value-vertex) to the newly created dataflow graph,
 which holds a reference to the constant. If you are confused with the use of the ${ctx.link('ParentInformation')} type, 
-this stems from the [AST decoration](#normalization) and signals that we have a decorated ${ctx.link('RNode')} (which may have additional information in \`OtherInfo\`).
+this stems from the [AST decoration](#normalization) and signals that we have a decorated ${ctx.link(model_1.RNode)} (which may have additional information in \`OtherInfo\`).
 
 Yet again, this is not very interesting. When looking at the ${ctx.link('processors')} object you may be confused by
 many lines just mapping the node to the ${ctx.link(process_named_call_1.processAsNamedCall)} function.
@@ -426,7 +425,7 @@ to produce a new dataflow information.
 
 Given the [dataflow graph](${doc_files_1.FlowrWikiBaseRef}/Dataflow-Graph), you can do a lot more!
 You can issue [queries](${doc_files_1.FlowrWikiBaseRef}/Query-API) to explore the graph, [search](${doc_files_1.FlowrWikiBaseRef}/Search-API) for specific elements, or, for example, request a [static backward slice](#static-backward-slicing).
-Of course, all of these endeavors work not just with the ${ctx.link(shell_1.RShell.name)} but also with the [\`tree-sitter\` engine](${doc_files_1.FlowrWikiBaseRef}/Engines). 
+Of course, all of these endeavors work not just with the ${ctx.link(shell_1.RShell)} but also with the [\`tree-sitter\` engine](${doc_files_1.FlowrWikiBaseRef}/Engines). 
 
 ### Static Backward Slicing
 

package/documentation/wiki-dataflow-graph.js

@@ -38,11 +38,12 @@ const flowr_analyzer_builder_1 = require("../project/flowr-analyzer-builder");
 const flowr_analyzer_context_1 = require("../project/context/flowr-analyzer-context");
 const doc_maker_1 = require("./wiki-mk/doc-maker");
 const flowr_analyzer_1 = require("../project/flowr-analyzer");
-const built_in_1 = require("../dataflow/environments/built-in");
 const dfg_1 = require("../util/mermaid/dfg");
 const r_number_1 = require("../r-bridge/lang-4.x/ast/model/nodes/r-number");
 const model_1 = require("../r-bridge/lang-4.x/ast/model/model");
 const range_1 = require("../util/range");
+const df_helper_1 = require("../dataflow/graph/df-helper");
+const built_in_proc_name_1 = require("../dataflow/environments/built-in-proc-name");
 async function subExplanation(parser, { description, code, expectedSubgraph }) {
     expectedSubgraph = await (0, doc_dfg_1.verifyExpectedSubgraph)(parser, code, expectedSubgraph);
     const marks = [];
@@ -170,7 +171,7 @@ ${(0, doc_structure_1.block)({
                 content: `
 	If you want to obtain the locations where a variable is defined, or read, or re-defined, refrain from tracking these details manually in the dataflow graph
 	as there are some edge-cases that require special attention.
-	In general, the ${ctx.link(dfg_get_origin_1.getOriginInDfg)} function explained below in [working with the dataflow graph](${doc_files_1.FlowrWikiBaseRef}/Dataflow%20Graph#working-with-the-dataflow-graph) will help you to get the information you need.
+	In general, the ${ctx.link(dfg_get_origin_1.getOriginInDfg)} (which is also available as ${ctx.linkO(df_helper_1.Dataflow, 'origin')}) function explained below in [working with the dataflow graph](${doc_files_1.FlowrWikiBaseRef}/Dataflow%20Graph#working-with-the-dataflow-graph) will help you to get the information you need.
 	`
             })}
 
@@ -196,8 +197,8 @@ ${ctx.hierarchy('FunctionArgument')}
 
 There is another element of potential interest to you, the \`origin\` property which records how flowR created the respective function call.
 These origins may hold the name of any processor that is part of the ${ctx.link('BuiltInProcName')} enumeration to signal that the respective processor (cf. ${ctx.link('BuiltInProcessorMapper')}) was responsible for creating the vertex.
-The entry \`${built_in_1.BuiltInProcName.Function}\` signals that flowR used a processor for a user-defined function defined within the source code, \`${built_in_1.BuiltInProcName.Unnamed}\` signals that the function as an anonymous function definition.
-However, in general, flowR may use any fitting handler as an origin (see the ${ctx.link('BuiltInProcName')} enum for a *complete* list). For example, within a access definition, flowR will correspondingly redefine the meaning of \`:=\` to that of the \`${built_in_1.BuiltInProcName.TableAssignment}\`. 
+The entry \`${built_in_proc_name_1.BuiltInProcName.Function}\` signals that flowR used a processor for a user-defined function defined within the source code, \`${built_in_proc_name_1.BuiltInProcName.Unnamed}\` signals that the function as an anonymous function definition.
+However, in general, flowR may use any fitting handler as an origin (see the ${ctx.link('BuiltInProcName')} enum for a *complete* list). For example, within a access definition, flowR will correspondingly redefine the meaning of \`:=\` to that of the \`${built_in_proc_name_1.BuiltInProcName.TableAssignment}\`. 
 
 ${(0, doc_structure_1.details)('Example: Simple Function Call (unresolved)', await (async () => {
                 const code = 'foo(x,3,y=3,)';
@@ -367,7 +368,7 @@ ${(0, doc_structure_1.block)({
                 content: `Now you might be asking yourself how to differentiate anonymous and named functions and what you have to keep in mind when working with them?
 
 Unnamed functions have an array of signatures which you can use to identify them. 
-But in short: the \`origin\` attribute of the ${ctx.link('DataflowGraphVertexFunctionCall')} is \`${built_in_1.BuiltInProcName.Unnamed}\`.
+But in short: the \`origin\` attribute of the ${ctx.link('DataflowGraphVertexFunctionCall')} is \`${built_in_proc_name_1.BuiltInProcName.Unnamed}\`.
 Please be aware that unnamed functions still have a \`name\` property to give it a unique identifier that can be used for debugging and reference.
 This name _always_ starts with \`${unnamed_call_handling_1.UnnamedFunctionCallPrefix}\`.
 
@@ -891,7 +892,7 @@ ${await getVertexExplanations(treeSitter, ctx)}
 
 ${(0, doc_structure_1.section)('Edges', 2, 'edges')}
 
-1. ${(0, doc_data_dfg_util_1.getAllEdges)().map(([k, v], index) => `[\`${k}\` (${v})](#${index + 1}-${k.toLowerCase().replace(/\s/g, '-')}-edge)`).join('\n1. ')}
+1. ${(0, doc_data_dfg_util_1.getAllEdges)().map(([k, v], index) => `[\`${k}\` (${v})](#${index + 1}-${k.toLowerCase().replaceAll(/\s/g, '-')}-edge)`).join('\n1. ')}
 
 ${await getEdgesExplanations(treeSitter, ctx)}
 
@@ -1052,7 +1053,8 @@ ${await (0, doc_dfg_1.printDfGraphForCode)(treeSitter, 'alias <- unknown\nalias(
 ${(0, doc_structure_1.section)('Working with the Dataflow Graph', 2, 'dfg-working')}
 
 The ${ctx.link('DataflowInformation')} is the core result of _flowR_ and summarizes a lot of information.
-Depending on what you are interested in, there exists a plethora of functions and queries to help you out, answering the most important questions:
+Depending on what you are interested in, there exists a plethora of functions and queries to help you out, answering the most important questions.
+Generally, we recommend you check out the ${ctx.link(df_helper_1.Dataflow, undefined, { type: 'variable' })} helper object!
 
 * The **${ctx.linkPage('wiki/Query API')}** provides many functions to query the dataflow graph for specific information (dependencies, calls, slices, clusters, ...)
 * The **${ctx.linkPage('wiki/Search API')}** allows you to search for specific vertices or edges in the dataflow graph or the original program
@@ -1064,9 +1066,9 @@ Depending on what you are interested in, there exists a plethora of functions an
 
 FlowR also provides various helper objects (with the same name as the corresponding type) to help you work with the dataflow graph:
 
-* ${ctx.link('DfEdge', undefined, { type: 'variable' })} to get helpful functions wrt. edges (see [below](#dfg-resolving-values))
-* ${ctx.link('Identifier', undefined, { type: 'variable' })} to get helpful functions wrt. identifiers
-* ${ctx.link('FunctionArgument', undefined, { type: 'variable' })} to get helpful functions wrt. function arguments
+* ${ctx.link(edge_1.DfEdge, undefined, { type: 'variable' })} to get helpful functions wrt. edges (see [below](#dfg-resolving-values))
+* ${ctx.link(identifier_1.Identifier, undefined, { type: 'variable' })} to get helpful functions wrt. identifiers
+* ${ctx.link(graph_1.FunctionArgument, undefined, { type: 'variable' })} to get helpful functions wrt. function arguments
 
 Some of these functions have been explained in their respective wiki pages. However, some are part of the ${ctx.linkPage('wiki/Dataflow Graph', 'Dataflow Graph API')} and so we explain them here.
 If you are interested in which features we support and which features are still to be worked on, please refer to our ${ctx.linkPage('wiki/Capabilities', 'capabilities')} page.
@@ -1107,14 +1109,14 @@ ${await (async () => {
                 }
                 throw new Error('Could not find edge');
             })()}&mdash;which is usually not very helpful.
-You can use ${ctx.link('DfEdge::splitTypes')} to get the individual bitmasks of all included types, and 
-${ctx.link('DfEdge::includesType')} to check whether a specific type (or one of a collection of types) is included in the edge.
+You can use ${ctx.linkO(edge_1.DfEdge, 'splitTypes')} to get the individual bitmasks of all included types, and 
+${ctx.linkO(edge_1.DfEdge, 'includesType')} to check whether a specific type (or one of a collection of types) is included in the edge.
 
 ${(0, doc_structure_1.section)('Handling Origins', 3, 'dfg-handling-origins')}
 
 If you are writing another analysis on top of the dataflow graph, you probably want to know all definitions that serve as the source of a read, all functions
 that are called by an invocation, and more.
-For this, the ${ctx.link(dfg_get_origin_1.getOriginInDfg)} function provides you with a collection of ${ctx.link('Origin')} objects:
+For this, the ${ctx.link(dfg_get_origin_1.getOriginInDfg)} (this is also accessible with ${ctx.linkO(df_helper_1.Dataflow, 'origin')}) function provides you with a collection of ${ctx.link('Origin')} objects:
 
 ${ctx.hierarchy('Origin', { openTop: true })}
 

package/documentation/wiki-interface.js

@@ -18,8 +18,8 @@ const flowr_main_options_1 = require("../cli/flowr-main-options");
 const doc_issue_1 = require("./doc-util/doc-issue");
 const doc_structure_1 = require("./doc-util/doc-structure");
 const doc_maker_1 = require("./wiki-mk/doc-maker");
-const built_in_1 = require("../dataflow/environments/built-in");
 const doc_writing_code_1 = require("./data/interface/doc-writing-code");
+const built_in_proc_name_1 = require("../dataflow/environments/built-in-proc-name");
 async function explainServer(parser) {
     (0, doc_data_server_messages_1.documentAllServerMessages)();
     return `
@@ -200,7 +200,7 @@ ${await (0, doc_repl_1.documentReplSession)(parser, [{
 For more information on the available queries, please check out the ${ctx.linkPage('wiki/Query API', 'Query API')}.
 `;
 }
-function explainConfigFile() {
+function explainConfigFile(ctx) {
     return `
 
 When running _flowR_, you may want to specify some behaviors with a dedicated configuration file. 
@@ -211,6 +211,8 @@ Within the REPL this works by running the following:
 
 ${(0, doc_code_1.codeBlock)('shell', ':query @config')}
 
+To work with the ${ctx.link(config_1.FlowrConfig)} you can use the provided helper objects alongside its methods like
+${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.
@@ -234,7 +236,7 @@ ${(0, doc_code_1.codeBlock)('json', JSON.stringify({
             environment: {
                 overwriteBuiltIns: {
                     definitions: [
-                        { type: 'function', names: ['foo'], processor: built_in_1.BuiltInProcName.Assignment, config: {} }
+                        { type: 'function', names: ['foo'], processor: built_in_proc_name_1.BuiltInProcName.Assignment, config: {} }
                     ]
                 }
             }
@@ -288,7 +290,7 @@ ${(0, doc_code_1.codeBlock)('json', JSON.stringify({
   | Type            | Description                                                                                                                                                                                                                                                                                              | Example                                                                                                    |
   | --------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- |
   | \`constant\`    | Additionally allows for a \`value\` this should resolve to.                                                                                                                                                                                                                                                | \`{ type: 'constant', names: ['NULL', 'NA'],  value: null }\`                                                |
-  | \`function\`    | Is a rather flexible way to define and bind built-in functions. For the time, we do not have extensive documentation to cover all the cases, so please either consult the sources with the \`default-builtin-config.ts\` or open a [new issue](${doc_issue_1.NewIssueUrl}). | \`{ type: 'function', names: ['next'], processor: '${built_in_1.BuiltInProcName.Default}', config: { cfg: ExitPointType.Next } }\` |
+  | \`function\`    | Is a rather flexible way to define and bind built-in functions. For the time, we do not have extensive documentation to cover all the cases, so please either consult the sources with the \`default-builtin-config.ts\` or open a [new issue](${doc_issue_1.NewIssueUrl}). | \`{ type: 'function', names: ['next'], processor: '${built_in_proc_name_1.BuiltInProcName.Default}', config: { cfg: ExitPointType.Next } }\` |
   | \`replacement\` | A comfortable way to specify replacement functions like \`$<-\` or \`names<-\`. \`suffixes\` describes the... suffixes to attach automatically. | \`{ type: 'replacement', suffixes: ['<-', '<<-'], names: ['[', '[['] }\` |
 
 
@@ -298,7 +300,7 @@ ${(0, doc_code_1.codeBlock)('json', JSON.stringify({
 
 <summary style='color:gray'>Full Configuration-File Schema</summary>
 
-${(0, schema_1.describeSchema)(config_1.flowrConfigFileSchema, ansi_1.markdownFormatter)}
+${(0, schema_1.describeSchema)(config_1.FlowrConfig.Schema, ansi_1.markdownFormatter)}
 
 </details>
 
@@ -331,7 +333,7 @@ ${await explainRepl(treeSitter, ctx)}
 <a id='configuring-flowr'></a>
 ## ⚙️ Configuring FlowR
 
-${explainConfigFile()}
+${explainConfigFile(ctx)}
 
 <a id='writing-code'></a>
 ## ⚒️ Writing Code

package/documentation/wiki-linter.js

@@ -46,12 +46,12 @@ function prettyPrintExpectedOutput(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] ?? '';
+    const indentation = lines.at(-1)?.match(/^\s*/)?.[0] ?? '';
     return lines.map((line, i) => {
         if (i === 0) {
             return line;
         }
-        return line.replace(new RegExp('^' + indentation, 'g'), '');
+        return line.replaceAll(new RegExp('^' + indentation, 'g'), '');
     }).join('\n');
 }
 function buildSamplesFromLinterTestCases(_parser, testFile) {
@@ -122,6 +122,7 @@ df[6, "value"]
 `, tagTypes);
     rule(knownParser, 'dead-code', 'DeadCodeConfig', 'DEAD_CODE', 'lint-dead-code', 'if(TRUE) 1 else 2', tagTypes);
     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);
     function rule(parser, name, configType, ruleType, testfile, example, types) {
         const rule = linter_rules_1.LintingRules[name];
         const tags = rule.info.tags.toSorted((a, b) => {
@@ -236,7 +237,7 @@ We use tags to categorize linting rules for users. The following tags are availa
 | Tag/Badge   | 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${getAllLintingRulesWithTag(tag).length === 1 ? '' : 's'}: ${(0, strings_1.joinWithLast)(getAllLintingRulesWithTag(tag).map(l => linkToRule(l))) || '_none_'}) | `;
+        return `| <a id="${tag}"></a> ${(makeTagBadge(tag, tagTypes.info))} | ${(0, doc_types_1.getDocumentationForType)('LintingRuleTag::' + name, tagTypes.info).replaceAll('\n', ' ')} (rule${getAllLintingRulesWithTag(tag).length === 1 ? '' : 's'}: ${(0, strings_1.joinWithLast)(getAllLintingRulesWithTag(tag).map(l => linkToRule(l))) || '_none_'}) | `;
     }).join('\n')}
 
 ${(0, doc_structure_1.section)('Certainty', 2, 'certainty')}
@@ -248,14 +249,14 @@ ${(0, doc_structure_1.section)('Rule Certainty', 3, 'rule-certainty')}
 | Rule Certainty | Description |
 | -------------- | :---------- |
 ${Object.entries(linter_format_1.LintingRuleCertainty).map(([name, certainty]) => {
-        return `| <a id="${certainty}"></a> \`${certainty}\` | ${(0, doc_types_1.getDocumentationForType)('LintingRuleCertainty::' + name, tagTypes.info).replaceAll(/\n/g, ' ')} (rule${getAllLintingRulesWitCertainty(certainty).length === 1 ? '' : 's'}: ${(0, strings_1.joinWithLast)(getAllLintingRulesWitCertainty(certainty).map(l => linkToRule(l))) || '_none_'}) |`;
+        return `| <a id="${certainty}"></a> \`${certainty}\` | ${(0, doc_types_1.getDocumentationForType)('LintingRuleCertainty::' + name, tagTypes.info).replaceAll('\n', ' ')} (rule${getAllLintingRulesWitCertainty(certainty).length === 1 ? '' : 's'}: ${(0, strings_1.joinWithLast)(getAllLintingRulesWitCertainty(certainty).map(l => linkToRule(l))) || '_none_'}) |`;
     }).join('\n')}
 	
 ${(0, doc_structure_1.section)('Result Certainty', 3, 'result-certainty')}
 
 | Result Certainty | Description |
 | ---------------- | :---------- |
-${Object.entries(linter_format_1.LintingResultCertainty).map(([name, certainty]) => `| <a id="${certainty}"></a> \`${certainty}\` | ${(0, doc_types_1.getDocumentationForType)('LintingResultCertainty::' + name, tagTypes.info).replaceAll(/\n/g, ' ')} |`).join('\n')}
+${Object.entries(linter_format_1.LintingResultCertainty).map(([name, certainty]) => `| <a id="${certainty}"></a> \`${certainty}\` | ${(0, doc_types_1.getDocumentationForType)('LintingResultCertainty::' + name, tagTypes.info).replaceAll('\n', ' ')} |`).join('\n')}
 
 `.trim();
 }

package/documentation/wiki-mk/doc-context.js

@@ -49,8 +49,7 @@ exports.ConstantWikiLinkInfo = {
  */
 function makeDocContextForTypes(shell, ...rootFolders) {
     if (rootFolders.length === 0) {
-        rootFolders.push(path_1.default.resolve(__dirname, '../../../src'));
-        rootFolders.push(path_1.default.resolve(__dirname, '../../../test/functionality'));
+        rootFolders.push(path_1.default.resolve(__dirname, '../../../src'), path_1.default.resolve(__dirname, '../../../test/functionality'));
     }
     const { info, program } = (0, doc_types_1.getTypesFromFolder)({ rootFolder: rootFolders, typeNameForMermaid: undefined });
     return {
@@ -108,10 +107,10 @@ function makeDocContextForTypes(shell, ...rootFolders) {
                 text ??= i.name;
             }
             else {
-                link = `${doc_files_1.FlowrWikiBaseRef}/${pageName.toLowerCase().replace(/ /g, '-')}`;
+                link = `${doc_files_1.FlowrGithubRef}/${pageName.toLowerCase().replaceAll(' ', '-')}`;
             }
             text ??= pageName.split('/').pop() ?? pageName;
-            return `[${text}](${link}${segment ? `#${segment}` : ''})`;
+            return `[${text}](${link}${segment ? '#' + segment : ''})`;
         },
         linkCode(path, lineNumber) {
             const lnk = lineNumber ? `${path.toString()}#L${lineNumber}` : path.toString();

package/documentation/wiki-normalized-ast.js

@@ -16,6 +16,7 @@ const roxygen_parse_1 = require("../r-bridge/roxygen2/roxygen-parse");
 const r_binary_op_1 = require("../r-bridge/lang-4.x/ast/model/nodes/r-binary-op");
 const model_1 = require("../r-bridge/lang-4.x/ast/model/model");
 const r_project_1 = require("../r-bridge/lang-4.x/ast/model/nodes/r-project");
+const r_expression_list_1 = require("../r-bridge/lang-4.x/ast/model/nodes/r-expression-list");
 async function quickNormalizedAstMultipleFiles() {
     const analyzer = await new flowr_analyzer_builder_1.FlowrAnalyzerBuilder()
         .setEngine('tree-sitter')
@@ -95,8 +96,8 @@ ${await (0, doc_normalized_ast_1.printNormalizedAstForCode)(treeSitter, 'x <- 2
 > you can either use the [Visual Studio Code extension](${doc_files_1.FlowrGithubBaseRef}/vscode-flowr) or the ${(0, doc_cli_option_1.getReplCommand)('normalize*')} 
 > command in the REPL (see the [Interface wiki page](${doc_files_1.FlowrWikiBaseRef}/Interface) for more information).
 
-Indicative of the normalization is the root ${ctx.link('RProject')} node, which is present in every normalized AST
-and provides the ${ctx.link('RExpressionList')} nodes for each file in the project.
+Indicative of the normalization is the root ${ctx.link(r_project_1.RProject)} node, which is present in every normalized AST
+and provides the ${ctx.link(r_expression_list_1.RExpressionList)} nodes for each file in the project.
 In general, we provide node types for:
 
 1. literals (e.g., numbers and strings)
@@ -112,7 +113,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', ctx.mermaid('RNode'))}
+${(0, doc_code_1.codeBlock)('mermaid', ctx.mermaid(model_1.RNode))}
 
 </details>
 
@@ -123,7 +124,7 @@ Most notably, the \`info\` field holds the \`id\` of the node, which is used to
 
 In summary, we have the following types:
 
-${(0, doc_structure_1.details)('Normalized AST Node Types', ctx.hierarchy('RNode', { collapseFromNesting: Number.MAX_VALUE, ignoredTypes: ['Info', 'LogLevel'] }))}
+${(0, doc_structure_1.details)('Normalized AST Node Types', ctx.hierarchy(model_1.RNode, { collapseFromNesting: Number.MAX_VALUE, ignoredTypes: ['Info', 'LogLevel'] }))}
 
 The following segments intend to give you an overview of how to work with the normalized AST:
 

package/documentation/wiki-query.js

@@ -29,7 +29,6 @@ const vertex_1 = require("../dataflow/graph/vertex");
 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");
-const _00_slice_1 = require("../core/steps/all/static-slicing/00-slice");
 const doc_repl_1 = require("./doc-util/doc-repl");
 const inspect_higher_order_query_executor_1 = require("../queries/catalog/inspect-higher-order-query/inspect-higher-order-query-executor");
 const doc_escape_1 = require("./doc-util/doc-escape");
@@ -39,6 +38,8 @@ const call_graph_query_executor_1 = require("../queries/catalog/call-graph-query
 const inspect_recursion_query_executor_1 = require("../queries/catalog/inspect-recursion-query/inspect-recursion-query-executor");
 const does_call_query_executor_1 = require("../queries/catalog/does-call-query/does-call-query-executor");
 const inspect_exception_query_executor_1 = require("../queries/catalog/inspect-exceptions-query/inspect-exception-query-executor");
+const slice_direction_1 = require("../util/slice-direction");
+const provenance_query_executor_1 = require("../queries/catalog/provenance-query/provenance-query-executor");
 (0, doc_query_1.registerQueryDocumentation)('call-context', {
     name: 'Call-Context Query',
     type: 'active',
@@ -554,7 +555,7 @@ To specify a variable of interest, you have to present flowR with a [slicing cri
 
 To exemplify the capabilities, consider the following code:
 ${(0, doc_code_1.codeBlock)('r', exampleCode)}
-If you are interested in the parts required for the use of \`x\` in the last line, you can use the following query:
+If you are interested in the parts required for the use of \`x\` in the last line and \`z\`, you can use the following query:
 
 ${await (0, doc_query_1.showQuery)(shell, exampleCode, [{
                 type: 'static-slice',
@@ -575,7 +576,7 @@ Likewise, if you want the forward slice for the first use of \`x\`, you can do i
 ${await (0, doc_query_1.showQuery)(shell, exampleCode, [{
                 type: 'static-slice',
                 criteria: ['1@x'],
-                direction: _00_slice_1.SliceDirection.Forward
+                direction: slice_direction_1.SliceDirection.Forward
             }], { showCode: false, shorthand: (0, doc_query_1.sliceQueryShorthand)(['1@x'], (0, doc_escape_1.escapeNewline)(exampleCode), true) })}
 
 You can disable [magic comments](${doc_files_1.FlowrWikiBaseRef}/Interface#slice-magic-comments) using the \`noMagicComments\` flag.
@@ -583,6 +584,30 @@ This query replaces the old [\`request-slice\`](${doc_files_1.FlowrWikiBaseRef}/
 		`;
     }
 });
+(0, doc_query_1.registerQueryDocumentation)('provenance', {
+    name: 'Provenance Query',
+    type: 'active',
+    shortDescription: 'Calculate the provenance of a given variable, optionally restricted to its enveloping fdef',
+    functionName: provenance_query_executor_1.executeProvenanceQuery.name,
+    functionFile: '../queries/catalog/provenance-query/provenance-query-executor.ts',
+    buildExplanation: async (shell) => {
+        const exampleCode = 'x <- 1\ny <- 2\nz <- 3\nx';
+        const criterion = '4@x';
+        return `
+Given a [slicing criterion](${doc_files_1.FlowrWikiBaseRef}/Terminology#slicing-criterion), flowR will return the provenance
+of the given program element (i.e., all related vertices in a non-interprocedural and non-context sensitive backward slice).
+
+To exemplify the capabilities, consider the following code:
+${(0, doc_code_1.codeBlock)('r', exampleCode)}
+If you are interested in the provenance of the \`x\` in the last line you can use:
+
+${await (0, doc_query_1.showQuery)(shell, exampleCode, [{
+                type: 'provenance',
+                criterion
+            }], { showCode: false, shorthand: (0, doc_query_1.sliceQueryShorthand)([criterion], (0, doc_escape_1.escapeNewline)(exampleCode)) })}
+`;
+    }
+});
 (0, doc_query_1.registerQueryDocumentation)('dependencies', {
     name: 'Dependencies Query',
     type: 'active',

package/engines.d.ts

@@ -1,9 +1,9 @@
-import { type FlowrConfigOptions, type KnownEngines } from './config';
+import { FlowrConfig, type KnownEngines } from './config';
 /**
  * Retrieve all requested engine instance.
  * Please make sure that if this includes the R engine, that you properly shut it down again!
  */
-export declare function retrieveEngineInstances(config: FlowrConfigOptions, defaultOnly?: boolean): Promise<{
+export declare function retrieveEngineInstances(config: FlowrConfig, defaultOnly?: boolean): Promise<{
     engines: KnownEngines;
     default: keyof KnownEngines;
 }>;

package/engines.js

@@ -12,9 +12,9 @@ const log_1 = require("./util/log");
  */
 async function retrieveEngineInstances(config, defaultOnly = false) {
     const engines = {};
-    if ((0, config_1.getEngineConfig)(config, 'r-shell') && (!defaultOnly || config.defaultEngine === 'r-shell')) {
+    if (config_1.FlowrConfig.getForEngine(config, 'r-shell') && (!defaultOnly || config.defaultEngine === 'r-shell')) {
         // we keep an active shell session to allow other parse investigations :)
-        engines['r-shell'] = new shell_1.RShell((0, config_1.getEngineConfig)(config, 'r-shell'), {
+        engines['r-shell'] = new shell_1.RShell(config_1.FlowrConfig.getForEngine(config, 'r-shell'), {
             revive: 2 /* RShellReviveOptions.Always */,
             onRevive: (code, signal) => {
                 const signalText = signal == null ? '' : ` and signal ${signal}`;
@@ -23,8 +23,8 @@ async function retrieveEngineInstances(config, defaultOnly = false) {
             }
         });
     }
-    if ((0, config_1.getEngineConfig)(config, 'tree-sitter') && (!defaultOnly || config.defaultEngine === 'tree-sitter')) {
-        await tree_sitter_executor_1.TreeSitterExecutor.initTreeSitter((0, config_1.getEngineConfig)(config, 'tree-sitter'));
+    if (config_1.FlowrConfig.getForEngine(config, 'tree-sitter') && (!defaultOnly || config.defaultEngine === 'tree-sitter')) {
+        await tree_sitter_executor_1.TreeSitterExecutor.initTreeSitter(config_1.FlowrConfig.getForEngine(config, 'tree-sitter'));
         engines['tree-sitter'] = new tree_sitter_executor_1.TreeSitterExecutor();
     }
     let defaultEngine = config.defaultEngine;

package/linter/linter-rules.d.ts

@@ -277,10 +277,33 @@ export declare const LintingRules: {
             readonly certainty: import("./linter-format").LintingRuleCertainty.BestEffort;
             readonly tags: readonly [import("./linter-tags").LintingRuleTag.Smell, import("./linter-tags").LintingRuleTag.Readability];
             readonly defaultConfig: {
-                readonly loopyFunctions: Set<import("../dataflow/environments/built-in").BuiltInProcName>;
+                readonly loopyFunctions: Set<import("../dataflow/environments/built-in-proc-name").BuiltInProcName>;
             };
         };
     };
+    readonly 'stop-call': {
+        readonly createSearch: () => import("../search/flowr-search-builder").FlowrSearchBuilder<"get", ["filter"], import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, Promise<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("../util/objects").MergeableRecord, { dataflow, analyzer }: {
+            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;
+        }) => {
+            results: import("ts-essentials").Writable<import("./rules/stop-with-call-arg").StopWithCallResult>[];
+            '.meta': import("./rules/stop-with-call-arg").StopWithCallMetadata;
+        };
+        readonly prettyPrint: {
+            readonly query: (result: import("./rules/stop-with-call-arg").StopWithCallResult) => string;
+            readonly full: (result: import("./rules/stop-with-call-arg").StopWithCallResult) => string;
+        };
+        readonly info: {
+            readonly name: "Stop without call.=False argument";
+            readonly tags: readonly [import("./linter-tags").LintingRuleTag.Smell];
+            readonly certainty: import("./linter-format").LintingRuleCertainty.BestEffort;
+            readonly description: "Checks whether stop calls without call. argument set to FALSE are used.";
+            readonly defaultConfig: {};
+        };
+    };
 };
 export type LintingRuleNames = keyof typeof LintingRules;
 export type LintingRuleMetadata<Name extends LintingRuleNames> = typeof LintingRules[Name] extends LintingRule<infer _Result, infer Metadata, infer _Config, infer _Info, infer _Elements> ? Metadata : never;

package/linter/linter-rules.js

@@ -11,6 +11,7 @@ const naming_convention_1 = require("./rules/naming-convention");
 const dataframe_access_validation_1 = require("./rules/dataframe-access-validation");
 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");
 /**
  * The registry of currently supported linting rules.
  * A linting rule can be executed on a dataflow pipeline result using {@link executeLintingRule}.
@@ -25,6 +26,7 @@ exports.LintingRules = {
     'network-functions': network_functions_1.NETWORK_FUNCTIONS,
     '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
+    'useless-loop': useless_loop_1.USELESS_LOOP,
+    'stop-call': stop_with_call_arg_1.STOP_WITH_CALL_ARG
 };
 //# sourceMappingURL=linter-rules.js.map

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

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DATA_FRAME_ACCESS_VALIDATION = void 0;
 const shape_inference_1 = require("../../abstract-interpretation/data-frame/shape-inference");
 const satisfiable_domain_1 = require("../../abstract-interpretation/domains/satisfiable-domain");
-const config_1 = require("../../config");
 const cfg_kind_1 = require("../../project/cfg-kind");
 const type_1 = require("../../r-bridge/lang-4.x/ast/model/type");
 const flowr_search_builder_1 = require("../../search/flowr-search-builder");
@@ -13,13 +12,14 @@ const range_1 = require("../../util/range");
 const linter_format_1 = require("../linter-format");
 const linter_tags_1 = require("../linter-tags");
 const identifier_1 = require("../../dataflow/environments/identifier");
+const config_1 = require("../../config");
 exports.DATA_FRAME_ACCESS_VALIDATION = {
     createSearch: () => flowr_search_builder_1.Q.all().with(search_enrichers_1.Enrichment.CallTargets, { onlyBuiltin: true }),
     processSearchResult: async (elements, config, data) => {
         let ctx = data.analyzer.inspectContext();
         ctx = {
             ...ctx,
-            config: (0, config_1.amendConfig)(data.analyzer.flowrConfig, flowrConfig => {
+            config: config_1.FlowrConfig.amend(data.analyzer.flowrConfig, flowrConfig => {
                 if (config.readLoadedData !== undefined) {
                     flowrConfig.abstractInterpretation.dataFrame.readLoadedData.readExternalFiles = config.readLoadedData;
                 }
@@ -61,7 +61,7 @@ exports.DATA_FRAME_ACCESS_VALIDATION = {
             .map(({ nodeId, operand, ...accessed }) => ({
             ...accessed,
             node: data.normalize.idMap.get(nodeId),
-            operand: operand !== undefined ? data.normalize.idMap.get(operand) : undefined,
+            operand: operand === undefined ? undefined : data.normalize.idMap.get(operand),
         }))
             .map(({ node, operand, ...accessed }) => ({
             ...accessed,
@@ -76,10 +76,10 @@ exports.DATA_FRAME_ACCESS_VALIDATION = {
     prettyPrint: {
         [linter_format_1.LintingPrettyPrintContext.Query]: result => `Access of ${result.type} ` +
             (typeof result.accessed === 'string' ? `"${result.accessed}"` : result.accessed) + ' ' +
-            (result.operand !== undefined ? `of \`${result.operand}\`` : `at \`${result.access}\``) + ` at ${range_1.SourceRange.format(result.range)}`,
+            (result.operand === undefined ? `at \`${result.access}\`` : `of \`${result.operand}\``) + ` at ${range_1.SourceRange.format(result.range)}`,
         [linter_format_1.LintingPrettyPrintContext.Full]: result => `Accessed ${result.type} ` +
             (typeof result.accessed === 'string' ? `"${result.accessed}"` : result.accessed) + ' does not exist ' +
-            (result.operand !== undefined ? `in \`${result.operand}\`` : `at \`${result.access}\``) + ` at ${range_1.SourceRange.format(result.range)}`
+            (result.operand === undefined ? `at \`${result.access}\`` : `in \`${result.operand}\``) + ` at ${range_1.SourceRange.format(result.range)}`
     },
     info: {
         name: 'Dataframe Access Validation',

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

@@ -53,7 +53,7 @@ export declare function getMostUsedCasing(symbols: {
 /**
  * Attempts to fix the casing of the given identifier to match the provided convention.
  */
-export declare function fixCasing(identifier: string, convention: CasingConvention): string | undefined;
+export declare function fixCasing(identifier: string, convention: CasingConvention, ignorePrefix?: string): string | undefined;
 /**
  * Creates quick fixes for renaming all references to the given node to match the provided replacement.
  */

package/linter/rules/naming-convention.js

@@ -91,11 +91,15 @@ function getMostUsedCasing(symbols) {
 /**
  * Attempts to fix the casing of the given identifier to match the provided convention.
  */
-function fixCasing(identifier, convention) {
+function fixCasing(identifier, convention, ignorePrefix) {
     if (!containsAlpha(identifier)) {
         return undefined;
     }
-    const tokens = identifier.split(/(?=[A-Z])|_/).map(s => s.toLowerCase());
+    if (ignorePrefix) {
+        identifier = identifier.replace(new RegExp(`^(${ignorePrefix})`), '');
+    }
+    const splitOn = identifier.includes('_') ? /_/ : /(?=[A-Z])/;
+    const tokens = identifier.split(splitOn).map(s => s.toLowerCase());
     const firstUp = (s) => {
         if (s.length < 1) {
             return s.toUpperCase();
@@ -167,7 +171,7 @@ exports.NAMING_CONVENTION = {
         const results = symbols
             .filter(m => (m.detectedCasing !== casing) && (!config.ignoreNonAlpha || containsAlpha(m.name)))
             .map(({ id, ...m }) => {
-            const fix = fixCasing(m.name, casing);
+            const fix = fixCasing(m.name, casing, config.ignorePrefix);
             return {
                 ...m,
                 involvedId: id,