@eagleoutice/flowr 2.5.0 → 2.6.0

package/documentation/print-analyzer-wiki.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const shell_1 = require("../r-bridge/shell");
+const log_1 = require("../../test/functionality/_helper/log");
+const doc_auto_gen_1 = require("./doc-util/doc-auto-gen");
+const doc_types_1 = require("./doc-util/doc-types");
+const path_1 = __importDefault(require("path"));
+const flowr_analyzer_1 = require("../project/flowr-analyzer");
+const flowr_analyzer_builder_1 = require("../project/flowr-analyzer-builder");
+const doc_structure_1 = require("./doc-util/doc-structure");
+const doc_files_1 = require("./doc-util/doc-files");
+async function analyzerQuickExample() {
+    const analyzer = await new flowr_analyzer_builder_1.FlowrAnalyzerBuilder()
+        .addRequestFromInput('x <- 1; print(x)')
+        .setEngine('tree-sitter')
+        .build();
+    // get the dataflow
+    const df = await analyzer.dataflow();
+    // obtain the identified loading order
+    console.log(analyzer.inspectContext().files.loadingOrder.getLoadingOrder());
+    // run a dependency query
+    const results = await analyzer.query([{ type: 'dependencies' }]);
+    return { analyzer, df, results };
+}
+async function getText(shell) {
+    const rversion = (await shell.usedRVersion())?.format() ?? 'unknown';
+    const types = (0, doc_types_1.getTypesFromFolder)({
+        rootFolder: path_1.default.resolve('src/'),
+        inlineTypes: doc_types_1.mermaidHide
+    });
+    return `${(0, doc_auto_gen_1.autoGenHeader)({ filename: module.filename, purpose: 'analyzer', rVersion: rversion })}
+
+We are currently working on documenting the capabilities of the analyzer (with the plugins, their loading order, etc.). In general, the code documentation
+starting with the ${(0, doc_types_1.shortLink)(flowr_analyzer_1.FlowrAnalyzer.name, types.info)} and the ${(0, doc_types_1.shortLink)(flowr_analyzer_builder_1.FlowrAnalyzerBuilder.name, types.info)} 
+should be the best starting point.
+
+${(0, doc_structure_1.collapsibleToc)({
+        'Overview': undefined,
+        'Builder Configuration': undefined,
+        'Plugins': {
+            'Plugin Types': {
+                'Dependency Identification': undefined,
+                'Project Discovery': undefined,
+                'File Loading': undefined,
+                'Loading Order': undefined
+            },
+            'How to add a new plugin': undefined,
+            'How to add a new plugin type': undefined
+        },
+        'Context Information': {
+            'Files Context': undefined,
+            'Loading Order Context': undefined,
+            'Dependencies Context': undefined
+        },
+        'Analyzer Internals': undefined
+    })}
+
+
+${(0, doc_structure_1.section)('Overview', 2)}
+
+No matter whether you want to analyze a single R script, a couple of R notebooks, or a complete project,
+your journey starts with the ${(0, doc_types_1.shortLink)(flowr_analyzer_builder_1.FlowrAnalyzerBuilder.name, types.info)} (further described in [Builder Configuration](#builder-configuration) below).
+This builder allows you to configure the analysis in many different ways, for example, by specifying which files to analyze, which plugins to use, or
+what [Engine](${doc_files_1.FlowrWikiBaseRef}/Engines) to use for the analysis.
+ 
+${(0, doc_structure_1.block)({
+        type: 'NOTE',
+        content: `If you want to quickly try out the analyzer, you can use the following code snippet that analyzes a simple R expression:
+	
+${(0, doc_types_1.printCodeOfElement)({ program: types.program, info: types.info, dropLinesStart: 1, dropLinesEnd: 2, hideDefinedAt: true }, analyzerQuickExample.name)}
+		`
+    })} 
+
+**TODO**: mention [Context](#Context_Information) 
+
+${(0, doc_structure_1.section)('Builder Configuration', 2)}
+
+**TODO** also explain buildSync and that TreeSitter has to be initialized for this 
+
+${(0, doc_structure_1.section)('Plugins', 2)}
+
+${(0, doc_structure_1.section)('Plugin Types', 3)}
+
+During the construction of a new ${(0, doc_types_1.shortLink)(flowr_analyzer_1.FlowrAnalyzer.name, types.info)}, plugins of different types are applied at different stages of the analysis.
+These plugins are grouped by their ${(0, doc_types_1.shortLink)('PluginType', types.info)} and are applied in the following order (as shown in the documentation of the ${(0, doc_types_1.shortLink)('PluginType', types.info)}):
+
+${(() => {
+        const doc = (0, doc_types_1.getDocumentationForType)('PluginType', types.info);
+        // skip until the first ```text
+        const lines = doc.split('\n');
+        const start = lines.findIndex(l => l.trim().startsWith('```text'));
+        const end = lines.findIndex((l, i) => i > start && l.trim().startsWith('```'));
+        // github rendering pls fix xD
+        return start >= 0 && end > start ? '```text\n' + lines.slice(start + 1, end).join('\n').replaceAll('▶', '>') + '\n```' : doc;
+    })()}
+
+We describe the different plugin types in more detail below.
+
+
+${(0, doc_structure_1.section)('Project Discovery', 4)}
+
+${(0, doc_structure_1.section)('File Loading', 4)}
+
+${(0, doc_structure_1.section)('Dependency Identification', 4)}
+
+${(0, doc_structure_1.section)('Loading Order', 4)}
+
+${(0, doc_structure_1.section)('How to add a new plugin', 3)}
+
+${(0, doc_structure_1.section)('How to add a new plugin type', 3)}
+
+${(0, doc_structure_1.section)('Context Information', 2)}
+
+${(0, doc_structure_1.section)('Files Context', 3)}
+
+${(0, doc_structure_1.section)('Loading Order Context', 3)}
+
+${(0, doc_structure_1.section)('Dependencies Context', 3)}
+
+${(0, doc_structure_1.section)('Analyzer Internals', 2)}
+
+`;
+}
+/** if we run this script, we want a Markdown representation of the capabilities */
+if (require.main === module) {
+    (0, log_1.setMinLevelOfAllLogs)(6 /* LogLevel.Fatal */);
+    const shell = new shell_1.RShell();
+    void getText(shell).then(str => {
+        console.log(str);
+    }).finally(() => {
+        shell.close();
+    });
+}
+//# sourceMappingURL=print-analyzer-wiki.js.map

package/documentation/print-core-wiki.d.ts

@@ -1 +1,2 @@
-export {};
+import { FlowrAnalyzer } from '../project/flowr-analyzer';
+export declare function inspectContextExample(analyzer: FlowrAnalyzer): void;

package/documentation/print-core-wiki.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.inspectContextExample = inspectContextExample;
 const shell_1 = require("../r-bridge/shell");
 const log_1 = require("../../test/functionality/_helper/log");
 const log_2 = require("../util/log");
@@ -43,6 +44,36 @@ const pipeline_executor_1 = require("../core/pipeline-executor");
 const pipeline_1 = require("../core/steps/pipeline/pipeline");
 const static_slicer_1 = require("../slicing/static/static-slicer");
 const config_1 = require("../config");
+const flowr_analyzer_builder_1 = require("../project/flowr-analyzer-builder");
+const flowr_analyzer_1 = require("../project/flowr-analyzer");
+async function makeAnalyzerExample() {
+    const analyzer = await new flowr_analyzer_builder_1.FlowrAnalyzerBuilder()
+        .addRequestFromInput('x <- 1; y <- x; print(y);')
+        .amendConfig(c => {
+        c.ignoreSourceCalls = true;
+    })
+        .setEngine('tree-sitter')
+        .build();
+    return analyzer;
+}
+async function extractStepsExample(analyzer) {
+    const normalizedAst = await analyzer.normalize();
+    const dataflow = await analyzer.dataflow();
+    const cfg = await analyzer.controlflow();
+    return { normalizedAst, dataflow, cfg };
+}
+async function sliceQueryExample(analyzer) {
+    const result = await analyzer.query([{
+            type: 'static-slice',
+            criteria: ['1@y']
+        }]);
+    return result;
+}
+function inspectContextExample(analyzer) {
+    const ctx = analyzer.inspectContext();
+    console.log('dplyr version', ctx.deps.getDependency('dplyr'));
+    console.log('loading order', ctx.files.loadingOrder.getLoadingOrder());
+}
 async function getText(shell) {
     const rversion = (await shell.usedRVersion())?.format() ?? 'unknown';
     const sampleCode = 'x <- 1; print(x)';
@@ -80,6 +111,7 @@ See the [Getting flowR to Talk](#getting-flowr-to-talk) section below for more i
 `
     })}
 	
+* [Creating and Using a flowR Analyzer Instance](#creating-and-using-a-flowr-analyzer-instance)
 * [Pipelines and their Execution](#pipelines-and-their-execution)
 * [How flowR Produces Dataflow Graphs](#how-flowr-produces-dataflow-graphs)
   * [Overview](#overview)
@@ -89,10 +121,33 @@ See the [Getting flowR to Talk](#getting-flowr-to-talk) section below for more i
 * [Beyond the Dataflow Graph](#beyond-the-dataflow-graph)
   * [Static Backward Slicing](#static-backward-slicing)
 * [Getting flowR to Talk](#getting-flowr-to-talk)
-	
+
+## Creating and Using a flowR Analyzer Instance
+
+The ${(0, doc_types_1.shortLink)(flowr_analyzer_builder_1.FlowrAnalyzerBuilder.name, info)} class should be used as a starting point to create analyses in _flowR_.
+It provides a fluent interface for the configuration and creation of a ${(0, doc_types_1.shortLink)(flowr_analyzer_1.FlowrAnalyzer.name, info)} instance:
+
+${(0, doc_types_1.printCodeOfElement)({ program, info, dropLinesStart: 1, dropLinesEnd: 2, hideDefinedAt: true }, makeAnalyzerExample.name)}
+
+Have a look at the [Engine](${doc_files_1.FlowrWikiBaseRef}/Engines) wiki page to understand the different engines and parsers you can use.
+
+The analyzer instance can then be used to access analysis results like the [normalized AST](${doc_files_1.FlowrWikiBaseRef}/Normalized-AST),
+the [dataflow graph](${doc_files_1.FlowrWikiBaseRef}/Dataflow-Graph), and the [controlflow graph](${doc_files_1.FlowrWikiBaseRef}/Control-Flow-Graph):
+
+${(0, doc_types_1.printCodeOfElement)({ program, info, dropLinesStart: 1, dropLinesEnd: 2, hideDefinedAt: true }, extractStepsExample.name)}
+
+The underlying ${(0, doc_types_1.shortLink)(flowr_analyzer_1.FlowrAnalyzer.name, info)} instance will take care of caching, updates, and running the appropriate steps.
+It also exposes the [query API](${doc_files_1.FlowrWikiBaseRef}/Query-API):
+
+${(0, doc_types_1.printCodeOfElement)({ program, info, dropLinesStart: 1, dropLinesEnd: 2, hideDefinedAt: true }, sliceQueryExample.name)}
+
+One of the additional advantages of using the ${(0, doc_types_1.shortLink)(flowr_analyzer_1.FlowrAnalyzer.name, info)} is that it provides you with context information about the analyzed files:
+
+${(0, doc_types_1.printCodeOfElement)({ program, info, dropLinesStart: 1, dropLinesEnd: 1, hideDefinedAt: true }, inspectContextExample.name)}
+
 ## Pipelines and their Execution
 
-At the core of every analysis by flowR is the ${(0, doc_types_1.shortLink)(pipeline_executor_1.PipelineExecutor.name, info)} class which takes a sequence of analysis steps (in the form of a ${(0, doc_types_1.shortLink)('Pipeline', info)}) and executes it
+At the core of every analysis done via a ${(0, doc_types_1.shortLink)(flowr_analyzer_1.FlowrAnalyzer.name, info)} is the ${(0, doc_types_1.shortLink)(pipeline_executor_1.PipelineExecutor.name, info)} class which takes a sequence of analysis steps (in the form of a ${(0, doc_types_1.shortLink)('Pipeline', info)}) and executes it
 on a given input. In general, these pipeline steps are analysis agnostic and may use arbitrary input and ordering. However, two important and predefined pipelines, 
 the ${(0, doc_types_1.shortLink)('DEFAULT_DATAFLOW_PIPELINE', info)} and the ${(0, doc_types_1.shortLink)('TREE_SITTER_DATAFLOW_PIPELINE', info)} adequately cover the most common analysis steps 
 (differentiated only by the [Engine](${doc_files_1.FlowrWikiBaseRef}/Engines) used).
@@ -115,10 +170,9 @@ const executor = new PipelineExecutor(TREE_SITTER_DATAFLOW_PIPELINE, {
 const result = await executor.allRemainingSteps();
 `)}
 
-This is, roughly, what the ${(0, doc_types_1.shortLink)('replGetDataflow', info)} function does for the ${(0, doc_cli_option_1.getReplCommand)('dataflow')} REPL command when using the [\`tree-sitter\` engine](${doc_files_1.FlowrWikiBaseRef}/Engines).
+This is, roughly, what the ${(0, doc_types_1.shortLink)('dataflow', info)} function does when using the [\`tree-sitter\` engine](${doc_files_1.FlowrWikiBaseRef}/Engines).
 We create a new ${(0, doc_types_1.shortLink)(pipeline_executor_1.PipelineExecutor.name, info)} with the ${(0, doc_types_1.shortLink)('TREE_SITTER_DATAFLOW_PIPELINE', info)} and then use ${(0, doc_types_1.shortLink)(`${pipeline_executor_1.PipelineExecutor.name}::${new pipeline_executor_1.PipelineExecutor(default_pipelines_1.TREE_SITTER_PARSE_PIPELINE, { parser: new tree_sitter_executor_1.TreeSitterExecutor(), request: (0, retriever_1.requestFromInput)('') }, config_1.defaultConfigOptions).allRemainingSteps.name}`, info)} 
 to cause the execution of all contained steps (in general, pipelines can be executed step-by-step, but this is usually not required if you just want the result).
-${(0, doc_types_1.shortLink)(retriever_1.requestFromInput.name, info)} is merely a convenience function to create a request object from a code string.
 
 In general, however, most flowR-internal functions which are tasked with generating dataflow prefer the use of ${(0, doc_types_1.shortLink)(default_pipelines_1.createDataflowPipeline.name, info)} as this function
 automatically selects the correct pipeline based on the engine used.

package/documentation/print-dataflow-graph-wiki.js

@@ -11,7 +11,6 @@ const dataflowgraph_builder_1 = require("../dataflow/graph/dataflowgraph-builder
 const assert_1 = require("../util/assert");
 const doc_dfg_1 = require("./doc-util/doc-dfg");
 const doc_files_1 = require("./doc-util/doc-files");
-const pipeline_executor_1 = require("../core/pipeline-executor");
 const retriever_1 = require("../r-bridge/retriever");
 const json_1 = require("../util/json");
 const doc_env_1 = require("./doc-util/doc-env");
@@ -39,6 +38,7 @@ const doc_issue_1 = require("./doc-util/doc-issue");
 const unnamed_call_handling_1 = require("../dataflow/internal/process/functions/call/unnamed-call-handling");
 const environment_builder_1 = require("../../test/functionality/_helper/dataflow/environment-builder");
 const config_1 = require("../config");
+const flowr_analyzer_builder_1 = require("../project/flowr-analyzer-builder");
 async function subExplanation(shell, { description, code, expectedSubgraph }) {
     expectedSubgraph = await (0, doc_dfg_1.verifyExpectedSubgraph)(shell, code, expectedSubgraph);
     const marks = [];
@@ -742,12 +742,9 @@ ${(0, doc_structure_1.details)('Example: While-Loop Body', await (0, doc_dfg_1.p
     return results.join('\n');
 }
 async function dummyDataflow() {
-    const shell = new shell_1.RShell();
-    const result = await new pipeline_executor_1.PipelineExecutor(default_pipelines_1.DEFAULT_DATAFLOW_PIPELINE, {
-        parser: shell,
-        request: (0, retriever_1.requestFromInput)('x <- 1\nx + 1')
-    }, config_1.defaultConfigOptions).allRemainingSteps();
-    shell.close();
+    const analyzer = await new flowr_analyzer_builder_1.FlowrAnalyzerBuilder((0, retriever_1.requestFromInput)('x <- 1\nx + 1')).build();
+    const result = await analyzer.dataflow();
+    analyzer.close();
     return result;
 }
 async function getText(shell) {
@@ -879,16 +876,12 @@ ${(0, doc_structure_1.details)('Example: Nested Conditionals', await (0, doc_dfg
 
 ${(0, doc_structure_1.section)('Dataflow Information', 2, 'dataflow-information')}
 
-Using _flowR's_ code interface (see the [Interface](${doc_files_1.FlowrWikiBaseRef}/Interface) wiki page for more), you can generate the dataflow information
-for a given piece of R code (in this case \`x <- 1; x + 1\`) as follows (using the ${(0, doc_types_1.shortLink)(shell_1.RShell.name, vertexType.info)} and the ${(0, doc_types_1.shortLink)(pipeline_executor_1.PipelineExecutor.name, vertexType.info)} classes):
+Using _flowR's_ code interface (see the [Interface](${doc_files_1.FlowrWikiBaseRef}/Interface#creating-flowr-analyses) wiki page for more), you can generate the dataflow information
+for a given piece of R code (in this case \`x <- 1; x + 1\`) as follows:
 
 ${(0, doc_code_1.codeBlock)('ts', `
-const shell = new ${shell_1.RShell.name}()
-const result = await new ${pipeline_executor_1.PipelineExecutor.name}(DEFAULT_DATAFLOW_PIPELINE, {
-    shell,
-    request:   ${retriever_1.requestFromInput.name}('x <- 1; x + 1')
-}).allRemainingSteps();
-shell.close();
+const analyzer = await new FlowrAnalyzerBuilder(requestFromInput('x <- 1\nx + 1')).build();
+const result = await analyzer.dataflow();
 `)}
 
 <details>
@@ -906,7 +899,7 @@ Now, you can find the dataflow _information_ with \`result.dataflow\`. More spec
 
 ${await (async () => {
         const result = await dummyDataflow();
-        const dfGraphString = (0, doc_dfg_1.printDfGraph)(result.dataflow.graph);
+        const dfGraphString = (0, doc_dfg_1.printDfGraph)(result.graph);
         return `
 ${dfGraphString}
 
@@ -917,7 +910,7 @@ However, the dataflow information contains more, quite a lot of information in f
 <summary style="color:gray">Dataflow Information as Json</summary>
 
 _As the information is pretty long, we inhibit pretty printing and syntax highlighting:_
-${(0, doc_code_1.codeBlock)('text', JSON.stringify(result.dataflow, json_1.jsonReplacer))}
+${(0, doc_code_1.codeBlock)('text', JSON.stringify(result, json_1.jsonReplacer))}
 
 </details>
 
@@ -925,16 +918,16 @@ You may be interested in its implementation:
 
 ${(0, doc_types_1.printHierarchy)({ program: vertexType.program, info: vertexType.info, root: 'DataflowInformation' })}
 
-Let's start by looking at the properties of the dataflow information object: ${Object.keys(result.dataflow).map(k => `\`${k}\``).join(', ')}.
+Let's start by looking at the properties of the dataflow information object: ${Object.keys(result).map(k => `\`${k}\``).join(', ')}.
 
 ${(() => {
             /* this includes the meta field for timing */
-            (0, assert_1.guard)(Object.keys(result.dataflow).length === 8, () => 'Update Dataflow Documentation!');
+            (0, assert_1.guard)(Object.keys(result).length === 8, () => 'Update Dataflow Documentation!');
             return '';
         })()}
 
 There are three sets of references.
-**in** (ids: ${JSON.stringify(new Set(result.dataflow.in.map(n => n.nodeId)), json_1.jsonReplacer)}) and **out** (ids: ${JSON.stringify(new Set(result.dataflow.out.map(n => n.nodeId)), json_1.jsonReplacer)}) contain the 
+**in** (ids: ${JSON.stringify(new Set(result.in.map(n => n.nodeId)), json_1.jsonReplacer)}) and **out** (ids: ${JSON.stringify(new Set(result.out.map(n => n.nodeId)), json_1.jsonReplacer)}) contain the 
 ingoing and outgoing references of the subgraph at hand (in this case, the whole code, as we are at the end of the dataflow analysis).
 Besides the Ids, they also contain important meta-information (e.g., what is to be read).
 The third set, **unknownReferences**, contains all references that are not yet identified as read or written 
@@ -944,12 +937,12 @@ The **environment** property contains the active environment information of the
 In other words, this is a linked list of tables (scopes), mapping identifiers to their respective definitions.
 A summarized version of the produced environment looks like this:
 
-${(0, doc_env_1.printEnvironmentToMarkdown)(result.dataflow.environment.current)}
+${(0, doc_env_1.printEnvironmentToMarkdown)(result.environment.current)}
 
 This shows us that the local environment contains a single definition for \`x\` (with id 0) and that the parent environment is the built-in environment.
 Additionally, we get the information that the node with the id 2 was responsible for the definition of \`x\`.
 
-Last but not least, the information contains the single **entry point** (${JSON.stringify(result.dataflow.entryPoint)}) and a set of **exit points** (${JSON.stringify(result.dataflow.exitPoints.map(e => e.nodeId))}). 
+Last but not least, the information contains the single **entry point** (${JSON.stringify(result.entryPoint)}) and a set of **exit points** (${JSON.stringify(result.exitPoints.map(e => e.nodeId))}). 
 Besides marking potential exits, the exit points also provide information about why the exit occurs and which control dependencies affect the exit.
 
 ### Unknown Side Effects

package/documentation/print-interface-wiki.js

@@ -25,6 +25,7 @@ const doc_structure_1 = require("./doc-util/doc-structure");
 const doc_types_1 = require("./doc-util/doc-types");
 const path_1 = __importDefault(require("path"));
 const tree_sitter_executor_1 = require("../r-bridge/lang-4.x/tree-sitter/tree-sitter-executor");
+const flowr_analyzer_1 = require("../project/flowr-analyzer");
 async function explainServer(shell) {
     (0, doc_data_server_messages_1.documentAllServerMessages)();
     return `
@@ -295,13 +296,29 @@ ${(0, doc_types_1.shortLink)(shell_1.RShell.name + '::' + shell.sendCommandWithO
 
 Besides that, the command ${(0, doc_types_1.shortLink)(shell_1.RShell.name + '::' + shell.tryToInjectHomeLibPath.name, types.info)} may be of interest, as it enables all libraries available on the host system.
 
+### Creating _flowR_ analyses
+
+Nowadays, instances of ${(0, doc_types_1.shortLink)(flowr_analyzer_1.FlowrAnalyzer.name, types.info)} should be used as central frontend to get analysis results from _flowR_.
+For example, a program slice can be created like this:
+
+${(0, doc_code_1.codeBlock)('ts', `
+const analyzer = await new FlowrAnalyzerBuilder(requestFromInput('x <- 1\\ny <- x\\nx')).build();
+const result = await analyzer.query([
+	{
+		type:     'static-slice',
+		criteria: ['3@x']
+	}
+]);
+//console.log(result['static-slice']);
+`)}
+        
 ### The Pipeline Executor
 
 Once, in the beginning, _flowR_ was meant to produce a dataflow graph merely to provide *program slices*. 
 However, with continuous updates, the [dataflow graph](${doc_files_1.FlowrWikiBaseRef}/Dataflow%20Graph) repeatedly proves to be the more interesting part.
 With this, we restructured _flowR_'s originally *hardcoded* pipeline to be far more flexible. 
 Now, it can be theoretically extended or replaced with arbitrary steps, optional steps, and what we call 'decorations' of these steps. 
-In short, if you still "just want to slice" you can do it like this with the ${(0, doc_types_1.shortLink)(pipeline_executor_1.PipelineExecutor.name, types.info)}:
+In short, a slicing pipeline using the ${(0, doc_types_1.shortLink)(pipeline_executor_1.PipelineExecutor.name, types.info)} looks like this:
 
 ${(0, doc_code_1.codeBlock)('ts', `
 const slicer = new ${pipeline_executor_1.PipelineExecutor.name}(DEFAULT_SLICING_PIPELINE, {

package/documentation/print-linter-wiki.js

@@ -87,10 +87,14 @@ See [here](${(0, doc_types_1.getTypePathLink)({ filePath: report.source.fileName
 }
 function registerRules(rVersion, shell, tagTypes, format = 'short') {
     const ruleExplanations = new Map();
-    rule(shell, 'deprecated-functions', 'DeprecatedFunctionsConfig', 'DEPRECATED_FUNCTIONS', 'lint-deprecated-functions', `
+    rule(shell, 'deprecated-functions', 'FunctionsToDetectConfig', 'DEPRECATED_FUNCTIONS', 'lint-deprecated-functions', `
 first <- data.frame(x = c(1, 2, 3), y = c(1, 2, 3))
 second <- data.frame(x = c(1, 3, 2), y = c(1, 3, 2))
 dplyr::all_equal(first, second)
+`, tagTypes);
+    rule(shell, 'network-functions', 'NetworkFunctionsConfig', 'NETWORK_FUNCTIONS', 'lint-network-functions', `
+read.csv("https://example.com/data.csv")
+download.file("https://foo.bar")
 `, tagTypes);
     rule(shell, 'file-path-validity', 'FilePathValidityConfig', 'FILE_PATH_VALIDITY', 'lint-file-path-validity', `
 my_data <- read.csv("C:/Users/me/Documents/My R Scripts/Reproducible.csv")

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

@@ -20,6 +20,7 @@ const visitor_1 = require("../r-bridge/lang-4.x/ast/model/processing/visitor");
 const collect_1 = require("../r-bridge/lang-4.x/ast/model/collect");
 const normalized_ast_fold_1 = require("../abstract-interpretation/normalized-ast-fold");
 const default_pipelines_1 = require("../core/steps/pipeline/default-pipelines");
+const flowr_analyzer_1 = require("../project/flowr-analyzer");
 async function getText(shell) {
     const rversion = (await shell.usedRVersion())?.format() ?? 'unknown';
     const now = performance.now();
@@ -91,17 +92,14 @@ The following segments intend to give you an overview of how to work with the no
 
 ## How to Get a Normalized AST
 
-As explained alongside the [Interface](${doc_files_1.FlowrWikiBaseRef}/Interface#the-pipeline-executor) wiki page, you can use the 
-${(0, doc_types_1.shortLink)(pipeline_executor_1.PipelineExecutor.name, types.info)} to get the ${(0, doc_types_1.shortLink)('NormalizedAst', types.info)}. If you are only interested in the normalization,
-a pipeline like the ${(0, doc_types_1.shortLink)('DEFAULT_NORMALIZE_PIPELINE', types.info)} suffices:
+As explained alongside the [Interface](${doc_files_1.FlowrWikiBaseRef}/Interface#creating-flowr-analyses) wiki page, you can use an instance of
+${(0, doc_types_1.shortLink)(flowr_analyzer_1.FlowrAnalyzer.name, types.info)} to get the ${(0, doc_types_1.shortLink)('NormalizedAst', types.info)}:
 
 ${(0, doc_code_1.codeBlock)('ts', `
 async function getAst(code: string): Promise<RNode> {
-    const result = await new ${pipeline_executor_1.PipelineExecutor.name}(DEFAULT_NORMALIZE_PIPELINE, {
-        parser:  new ${shell_1.RShell.name}(),
-        request: ${retriever_1.requestFromInput.name}(code.trim())
-    }).allRemainingSteps();
-    return result.normalize.ast;
+    const analyzer = await new FlowrAnalyzerBuilder(${retriever_1.requestFromInput.name}(code.trim())).build();
+    const result = analyzer.normalizedAst();
+    return result.ast;
 }`)}
 
 From the REPL, you can use the ${(0, doc_cli_option_1.getReplCommand)('normalize')} command.

package/engines.d.ts

@@ -0,0 +1,9 @@
+import type { FlowrConfigOptions, 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<{
+    engines: KnownEngines;
+    default: keyof KnownEngines;
+}>;

package/engines.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retrieveEngineInstances = retrieveEngineInstances;
+const config_1 = require("./config");
+const shell_1 = require("./r-bridge/shell");
+const ansi_1 = require("./util/text/ansi");
+const tree_sitter_executor_1 = require("./r-bridge/lang-4.x/tree-sitter/tree-sitter-executor");
+const log_1 = require("./util/log");
+/**
+ * Retrieve all requested engine instance.
+ * Please make sure that if this includes the R engine, that you properly shut it down again!
+ */
+async function retrieveEngineInstances(config, defaultOnly = false) {
+    const engines = {};
+    if ((0, config_1.getEngineConfig)(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'), {
+            revive: 2 /* RShellReviveOptions.Always */,
+            onRevive: (code, signal) => {
+                const signalText = signal == null ? '' : ` and signal ${signal}`;
+                console.log(ansi_1.formatter.format(`R process exited with code ${code}${signalText}. Restarting...`, { color: 5 /* Colors.Magenta */, effect: ansi_1.ColorEffect.Foreground }));
+                console.log((0, ansi_1.italic)(`If you want to exit, press either Ctrl+C twice, or enter ${(0, ansi_1.bold)(':quit')}`));
+            }
+        });
+    }
+    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'));
+        engines['tree-sitter'] = new tree_sitter_executor_1.TreeSitterExecutor();
+    }
+    let defaultEngine = config.defaultEngine;
+    if (!defaultEngine || !engines[defaultEngine]) {
+        // if a default engine isn't specified, we just take the first one we have
+        defaultEngine = Object.keys(engines)[0];
+    }
+    log_1.log.info(`Using engines ${Object.keys(engines).join(', ')} with default ${defaultEngine}`);
+    return { engines, default: defaultEngine };
+}
+//# sourceMappingURL=engines.js.map

package/linter/linter-executor.d.ts

@@ -1,11 +1,5 @@
 import type { LintingRuleConfig, LintingRuleNames } from './linter-rules';
-import type { NormalizedAst } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { DataflowInformation } from '../dataflow/info';
 import type { LintingResults } from './linter-format';
 import type { DeepPartial } from 'ts-essentials';
-import type { FlowrConfigOptions } from '../config';
-export declare function executeLintingRule<Name extends LintingRuleNames>(ruleName: Name, input: {
-    normalize: NormalizedAst;
-    dataflow: DataflowInformation;
-    config: FlowrConfigOptions;
-}, lintingRuleConfig?: DeepPartial<LintingRuleConfig<Name>>): LintingResults<Name>;
+import type { FlowrAnalysisProvider } from '../project/flowr-analyzer';
+export declare function executeLintingRule<Name extends LintingRuleNames>(ruleName: Name, input: FlowrAnalysisProvider, lintingRuleConfig?: DeepPartial<LintingRuleConfig<Name>>): Promise<LintingResults<Name>>;

package/linter/linter-executor.js

@@ -4,16 +4,21 @@ exports.executeLintingRule = executeLintingRule;
 const linter_rules_1 = require("./linter-rules");
 const flowr_search_executor_1 = require("../search/flowr-search-executor");
 const objects_1 = require("../util/objects");
-function executeLintingRule(ruleName, input, lintingRuleConfig) {
+async function executeLintingRule(ruleName, input, lintingRuleConfig) {
     try {
         const rule = linter_rules_1.LintingRules[ruleName];
         const fullConfig = (0, objects_1.deepMergeObject)(rule.info.defaultConfig, lintingRuleConfig);
-        const ruleSearch = rule.createSearch(fullConfig, input);
+        const ruleSearch = rule.createSearch(fullConfig);
         const searchStart = Date.now();
-        const searchResult = (0, flowr_search_executor_1.runSearch)(ruleSearch, input);
+        const searchResult = await (0, flowr_search_executor_1.runSearch)(ruleSearch, input);
         const searchTime = Date.now() - searchStart;
         const processStart = Date.now();
-        const result = rule.processSearchResult(searchResult, fullConfig, input);
+        const result = await rule.processSearchResult(searchResult, fullConfig, {
+            normalize: await input.normalize(),
+            dataflow: await input.dataflow(),
+            cfg: await input.controlflow(),
+            config: input.flowrConfig,
+        });
         const processTime = Date.now() - processStart;
         return {
             ...result,

package/linter/linter-format.d.ts

@@ -5,11 +5,12 @@ import type { GeneratorNames } from '../search/search-executor/search-generators
 import type { TransformerNames } from '../search/search-executor/search-transformer';
 import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { LintingRuleConfig, LintingRuleMetadata, LintingRuleNames, LintingRuleResult } from './linter-rules';
-import type { DataflowInformation } from '../dataflow/info';
-import type { FlowrConfigOptions } from '../config';
-import type { DeepPartial, DeepReadonly } from 'ts-essentials';
+import type { AsyncOrSync, DeepPartial, DeepReadonly } from 'ts-essentials';
 import type { LintingRuleTag } from './linter-tags';
 import type { SourceRange } from '../util/range';
+import type { DataflowInformation } from '../dataflow/info';
+import type { FlowrConfigOptions } from '../config';
+import type { ControlFlowInformation } from '../control-flow/control-flow-graph';
 export interface LinterRuleInformation<Config extends MergeableRecord = never> {
     /** Human-Readable name of the linting rule. */
     readonly name: string;
@@ -41,10 +42,7 @@ export interface LintingRule<Result extends LintingResult, Metadata extends Merg
      * Creates a flowR search that will then be executed and whose results will be passed to {@link processSearchResult}.
      * In the future, additional optimizations and transformations may be applied to the search between this function and {@link processSearchResult}.
      */
-    readonly createSearch: (config: Config, data: {
-        normalize: NormalizedAst;
-        dataflow: DataflowInformation;
-    }) => FlowrSearchLike<Info, GeneratorNames, TransformerNames[], FlowrSearchElements<Info, Elements>>;
+    readonly createSearch: (config: Config) => FlowrSearchLike<Info, GeneratorNames, TransformerNames[], FlowrSearchElements<Info, Elements>>;
     /**
      * Processes the search results of the search created through {@link createSearch}.
      * This function is expected to return the linting results from this rule for the given search, ie usually the given script file.
@@ -52,11 +50,12 @@ export interface LintingRule<Result extends LintingResult, Metadata extends Merg
     readonly processSearchResult: (elements: FlowrSearchElements<Info, Elements>, config: Config, data: {
         normalize: NormalizedAst;
         dataflow: DataflowInformation;
+        cfg: ControlFlowInformation;
         config: FlowrConfigOptions;
-    }) => {
+    }) => AsyncOrSync<{
         results: Result[];
         '.meta': Metadata;
-    };
+    }>;
     /**
      * A set of functions used to pretty-print the given linting result.
      * By default, the {@link LintingResult#certainty} and whether any {@link LintingResult#quickFix} values are available is automatically printed alongside this information.