@eagleoutice/flowr 2.6.2 → 2.7.0

package/linter/rules/file-path-validity.d.ts

@@ -35,7 +35,7 @@ export declare const FILE_PATH_VALIDITY: {
         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;
-        config: import("../../config").FlowrConfigOptions;
+        analyzer: import("../../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider;
     }) => {
         results: FilePathValidityResult[];
         ".meta": FilePathValidityMetadata;

package/linter/rules/file-path-validity.js

@@ -7,7 +7,6 @@ const dfg_1 = require("../../util/mermaid/dfg");
 const dependencies_query_format_1 = require("../../queries/catalog/dependencies-query/dependencies-query-format");
 const built_in_source_1 = require("../../dataflow/internal/process/functions/call/built-in/built-in-source");
 const logic_1 = require("../../util/logic");
-const retriever_1 = require("../../r-bridge/retriever");
 const happens_before_1 = require("../../control-flow/happens-before");
 const linter_tags_1 = require("../linter-tags");
 const search_enrichers_1 = require("../../search/search-executor/search-enrichers");
@@ -50,15 +49,16 @@ exports.FILE_PATH_VALIDITY = {
                     }
                 }
                 // check if any write to the same file happens before the read, and exclude this case if so
-                const writesToFile = results.write.filter(r => samePath(r.value, matchingRead.value, data.config.solver.resolveSource?.ignoreCapitalization));
+                const writesToFile = results.write.filter(r => samePath(r.value, matchingRead.value, data.analyzer.flowrConfig.solver.resolveSource?.ignoreCapitalization));
                 const writesBefore = writesToFile.map(w => (0, happens_before_1.happensBefore)(cfg, w.nodeId, element.node.info.id));
                 if (writesBefore.some(w => w === logic_1.Ternary.Always)) {
                     metadata.totalWritesBeforeAlways++;
                     return [];
                 }
                 // check if the file exists!
-                const paths = (0, built_in_source_1.findSource)(data.config.solver.resolveSource, matchingRead.value, {
-                    referenceChain: element.node.info.file ? [(0, retriever_1.requestFromInput)(`file://${element.node.info.file}`)] : []
+                const paths = (0, built_in_source_1.findSource)(data.analyzer.flowrConfig.solver.resolveSource, matchingRead.value, {
+                    referenceChain: element.node.info.file ? [element.node.info.file] : [],
+                    ctx: data.analyzer.inspectContext()
                 });
                 if (paths && paths.length) {
                     metadata.totalValid++;

package/linter/rules/function-finder-util.d.ts

@@ -5,8 +5,8 @@ import type { FlowrSearchElement, FlowrSearchElements } from '../../search/flowr
 import type { NormalizedAst, ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { MergeableRecord } from '../../util/objects';
 import type { DataflowInformation } from '../../dataflow/info';
-import type { FlowrConfigOptions } from '../../config';
 import type { FunctionInfo } from '../../queries/catalog/dependencies-query/function-info/function-info';
+import type { ReadonlyFlowrAnalysisProvider } from '../../project/flowr-analyzer';
 export interface FunctionsResult extends LintingResult {
     function: string;
     range: SourceRange;
@@ -26,11 +26,7 @@ export interface FunctionsToDetectConfig extends MergeableRecord {
  */
 export declare const functionFinderUtil: {
     createSearch: (functions: readonly string[]) => import("../../search/flowr-search-builder").FlowrSearchBuilder<"all", ["with", "filter"], ParentInformation, Promise<FlowrSearchElements<ParentInformation, [] | FlowrSearchElement<ParentInformation>[]>>>;
-    processSearchResult: <T extends FlowrSearchElement<ParentInformation>[]>(elements: FlowrSearchElements<ParentInformation, T>, _config: FunctionsToDetectConfig, _data: {
-        normalize: NormalizedAst;
-        dataflow: DataflowInformation;
-        config: FlowrConfigOptions;
-    }, refineSearch?: (elements: T) => T) => {
+    processSearchResult: <T extends FlowrSearchElement<ParentInformation>[]>(elements: FlowrSearchElements<ParentInformation, T>, _config: unknown, _data: unknown, refineSearch?: (elements: T) => T) => {
         results: {
             certainty: LintingResultCertainty;
             function: Identifier;
@@ -45,6 +41,6 @@ export declare const functionFinderUtil: {
     requireArgumentValue(element: FlowrSearchElement<ParentInformation>, pool: readonly FunctionInfo[], data: {
         normalize: NormalizedAst;
         dataflow: DataflowInformation;
-        config: FlowrConfigOptions;
+        analyzer: ReadonlyFlowrAnalysisProvider;
     }, requireValue: RegExp | string | undefined): boolean;
 };

package/linter/rules/function-finder-util.js

@@ -65,7 +65,7 @@ exports.functionFinderUtil = {
         }
         const vert = data.dataflow.graph.getVertex(element.node.info.id);
         if ((0, vertex_1.isFunctionCallVertex)(vert)) {
-            const args = (0, resolve_argument_1.getArgumentStringValue)(data.config.solver.variables, data.dataflow.graph, vert, info.argIdx, info.argName, info.resolveValue);
+            const args = (0, resolve_argument_1.getArgumentStringValue)(data.analyzer.flowrConfig.solver.variables, data.dataflow.graph, vert, info.argIdx, info.argName, info.resolveValue, data.analyzer.inspectContext());
             // we obtain all values, at least one of them has to trigger for the request
             const argValues = args ? args.values().flatMap(v => [...v]).filter(assert_1.isNotUndefined).toArray() : [];
             /* if there are no arguments we assume they may access the network, otherwise we check for the flag */

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

@@ -57,7 +57,7 @@ export declare const NAMING_CONVENTION: {
         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;
-        config: import("../../config").FlowrConfigOptions;
+        analyzer: import("../../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider;
     }) => {
         results: {
             quickFix: LintQuickFixReplacement[] | undefined;
@@ -78,7 +78,7 @@ export declare const NAMING_CONVENTION: {
     readonly info: {
         readonly name: "Naming Convention";
         readonly certainty: LintingRuleCertainty.OverApproximative;
-        readonly description: "Checks wether the symbols conform to a certain naming convention";
+        readonly description: "Checks whether the symbols conform to a certain naming convention";
         readonly tags: readonly [LintingRuleTag.Style, LintingRuleTag.QuickFix];
         readonly defaultConfig: {
             readonly caseing: "auto";

package/linter/rules/naming-convention.js

@@ -187,7 +187,7 @@ exports.NAMING_CONVENTION = {
         name: 'Naming Convention',
         // detects casing heuristically so correctness is not ensured using default config, but checks all identifiers in the code for naming convention match
         certainty: linter_format_1.LintingRuleCertainty.OverApproximative,
-        description: 'Checks wether the symbols conform to a certain naming convention',
+        description: 'Checks whether the symbols conform to a certain naming convention',
         tags: [linter_tags_1.LintingRuleTag.Style, linter_tags_1.LintingRuleTag.QuickFix],
         defaultConfig: {
             caseing: 'auto',

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

@@ -14,7 +14,7 @@ export declare const NETWORK_FUNCTIONS: {
         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;
-        config: import("../../config").FlowrConfigOptions;
+        analyzer: import("../../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider;
     }) => {
         results: {
             certainty: import("../linter-format").LintingResultCertainty;

package/linter/rules/network-functions.js

@@ -7,7 +7,7 @@ const linter_tags_1 = require("../linter-tags");
 const read_functions_1 = require("../../queries/catalog/dependencies-query/function-info/read-functions");
 exports.NETWORK_FUNCTIONS = {
     createSearch: (config) => function_finder_util_1.functionFinderUtil.createSearch(config.fns),
-    processSearchResult: (e, c, d) => function_finder_util_1.functionFinderUtil.processSearchResult(e, c, d, es => es.filter(e => function_finder_util_1.functionFinderUtil.requireArgumentValue(e, read_functions_1.ReadFunctions, d, c.onlyTriggerWithArgument))),
+    processSearchResult: (e, c, d) => function_finder_util_1.functionFinderUtil.processSearchResult(e, c, d, es => es.filter(e => function_finder_util_1.functionFinderUtil.requireArgumentValue(e, read_functions_1.ReadFunctions, { analyzer: d.analyzer, dataflow: d.dataflow, normalize: d.normalize }, c.onlyTriggerWithArgument))),
     prettyPrint: function_finder_util_1.functionFinderUtil.prettyPrint('network operations'),
     info: {
         name: 'Network Functions',

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

@@ -27,17 +27,18 @@ export interface SeededRandomnessMeta extends MergeableRecord {
     callsWithFunctionProducers: number;
     callsWithAssignmentProducers: number;
     callsWithNonConstantProducers: number;
+    callsWithOtherBranchProducers: number;
 }
 export declare const SEEDED_RANDOMNESS: {
     readonly createSearch: (config: SeededRandomnessConfig) => import("../../search/flowr-search-builder").FlowrSearchBuilder<"all", ["with", "filter", "with"], 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: SeededRandomnessConfig, { dataflow }: {
+    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: SeededRandomnessConfig, { 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;
-        config: import("../../config").FlowrConfigOptions;
+        analyzer: import("../../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider;
     }) => {
         results: {
-            certainty: LintingResultCertainty.Certain;
+            certainty: LintingResultCertainty;
             function: Identifier;
             range: SourceRange;
         }[];

package/linter/rules/seeded-randomness.js

@@ -16,6 +16,7 @@ const general_1 = require("../../dataflow/eval/values/general");
 const config_1 = require("../../config");
 const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const r_value_1 = require("../../dataflow/eval/values/r-value");
+const info_1 = require("../../dataflow/info");
 exports.SEEDED_RANDOMNESS = {
     createSearch: (config) => flowr_search_builder_1.Q.all()
         .with(search_enrichers_1.Enrichment.CallTargets, { onlyBuiltin: true })
@@ -30,14 +31,15 @@ exports.SEEDED_RANDOMNESS = {
         { callName: config.randomnessProducers.filter(p => p.type === 'function').map(p => p.name) },
         { callName: getDefaultAssignments().flatMap(b => b.names), cascadeIf: () => cascade_action_1.CascadeAction.Continue }
     ]),
-    processSearchResult: (elements, config, { dataflow }) => {
+    processSearchResult: (elements, config, { dataflow, analyzer }) => {
         const assignmentProducers = new Set(config.randomnessProducers.filter(p => p.type == 'assignment').map(p => p.name));
         const assignmentArgIndexes = new Map(getDefaultAssignments().flatMap(a => a.names.map(n => ([n, a.config?.swapSourceAndTarget ? 1 : 0]))));
         const metadata = {
             consumerCalls: 0,
             callsWithFunctionProducers: 0,
             callsWithAssignmentProducers: 0,
-            callsWithNonConstantProducers: 0
+            callsWithNonConstantProducers: 0,
+            callsWithOtherBranchProducers: 0
         };
         return {
             results: elements.getElements()
@@ -51,16 +53,25 @@ exports.SEEDED_RANDOMNESS = {
                 };
             }))
                 // filter by calls that aren't preceded by a randomness producer
-                .filter(element => {
+                .flatMap(element => {
+                const dfgElement = dataflow.graph.getVertex(element.searchElement.node.info.id);
+                const cds = dfgElement ? new Set(dfgElement.cds) : new Set();
                 const producers = (0, search_enrichers_1.enrichmentContent)(element.searchElement, search_enrichers_1.Enrichment.LastCall).linkedIds
                     .map(e => dataflow.graph.getVertex(e.node.info.id));
                 const { assignment, func } = Object.groupBy(producers, f => assignmentArgIndexes.has(f.name) ? 'assignment' : 'func');
                 let nonConstant = false;
+                let otherBranch = false;
                 // function calls are already taken care of through the LastCall enrichment itself
                 for (const f of func ?? []) {
-                    if (isConstantArgument(dataflow.graph, f, 0)) {
-                        metadata.callsWithFunctionProducers++;
-                        return false;
+                    if (isConstantArgument(dataflow.graph, f, 0, analyzer.inspectContext())) {
+                        const fCds = new Set(f.cds).difference(cds);
+                        if (fCds.size <= 0 || (0, info_1.happensInEveryBranchSet)(fCds)) {
+                            metadata.callsWithFunctionProducers++;
+                            return [];
+                        }
+                        else {
+                            otherBranch = true;
+                        }
                     }
                     else {
                         nonConstant = true;
@@ -71,9 +82,16 @@ exports.SEEDED_RANDOMNESS = {
                     const argIdx = assignmentArgIndexes.get(a.name);
                     const dest = (0, graph_1.getReferenceOfArgument)(a.args[argIdx]);
                     if (dest !== undefined && assignmentProducers.has((0, node_id_1.recoverName)(dest, dataflow.graph.idMap))) {
-                        if (isConstantArgument(dataflow.graph, a, 1 - argIdx)) {
-                            metadata.callsWithAssignmentProducers++;
-                            return false;
+                        // we either have arg index 0 or 1 for the assignmentProducers destination, so we select the assignment value as 1-argIdx here
+                        if (isConstantArgument(dataflow.graph, a, 1 - argIdx, analyzer.inspectContext())) {
+                            const aCds = new Set(a.cds).difference(cds);
+                            if (aCds.size <= 0 || (0, info_1.happensInEveryBranchSet)(aCds)) {
+                                metadata.callsWithAssignmentProducers++;
+                                return [];
+                            }
+                            else {
+                                otherBranch = true;
+                            }
                         }
                         else {
                             nonConstant = true;
@@ -83,13 +101,15 @@ exports.SEEDED_RANDOMNESS = {
                 if (nonConstant) {
                     metadata.callsWithNonConstantProducers++;
                 }
-                return true;
-            })
-                .map(element => ({
-                certainty: linter_format_1.LintingResultCertainty.Certain,
-                function: element.target,
-                range: element.range
-            })),
+                if (otherBranch) {
+                    metadata.callsWithOtherBranchProducers++;
+                }
+                return [{
+                        certainty: otherBranch ? linter_format_1.LintingResultCertainty.Uncertain : linter_format_1.LintingResultCertainty.Certain,
+                        function: element.target,
+                        range: element.range
+                    }];
+            }),
             '.meta': metadata
         };
     },
@@ -112,9 +132,9 @@ exports.SEEDED_RANDOMNESS = {
 function getDefaultAssignments() {
     return default_builtin_config_1.DefaultBuiltinConfig.filter(b => b.type === 'function' && b.processor == 'builtin:assignment');
 }
-function isConstantArgument(graph, call, argIndex) {
+function isConstantArgument(graph, call, argIndex, ctx) {
     const args = call.args.filter(arg => arg !== r_function_call_1.EmptyArgument && !arg.name).map(graph_1.getReferenceOfArgument);
-    const values = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(args[argIndex], { graph: graph, resolve: config_1.VariableResolve.Alias }));
+    const values = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(args[argIndex], { graph: graph, resolve: config_1.VariableResolve.Alias, ctx }));
     return values?.elements.every(v => v.type === 'number' ||
         v.type === 'logical' ||
         v.type === 'string' ||

package/linter/rules/unused-definition.d.ts

@@ -22,7 +22,7 @@ export declare const UNUSED_DEFINITION: {
         normalize: NormalizedAst;
         dataflow: import("../../dataflow/info").DataflowInformation;
         cfg: import("../../control-flow/control-flow-graph").ControlFlowInformation;
-        config: import("../../config").FlowrConfigOptions;
+        analyzer: import("../../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider;
     }) => {
         results: UnusedDefinitionResult[];
         ".meta": UnusedDefinitionMetadata;

package/linter/rules/useless-loop.d.ts

@@ -16,11 +16,11 @@ export interface UselessLoopMetadata extends MergeableRecord {
 }
 export declare const USELESS_LOOP: {
     readonly createSearch: () => import("../../search/flowr-search-builder").FlowrSearchBuilder<"all", ["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>[]>, useLessLoopConfig: UselessLoopConfig, { config, dataflow, normalize, cfg }: {
+    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>[]>, useLessLoopConfig: UselessLoopConfig, { analyzer, dataflow, normalize, cfg }: {
         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;
-        config: import("../../config").FlowrConfigOptions;
+        analyzer: import("../../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider;
     }) => {
         results: {
             certainty: LintingResultCertainty.Certain;

package/linter/rules/useless-loop.js

@@ -9,14 +9,14 @@ const linter_format_1 = require("../linter-format");
 const linter_tags_1 = require("../linter-tags");
 exports.USELESS_LOOP = {
     createSearch: () => flowr_search_builder_1.Q.all().filter(vertex_1.VertexType.FunctionCall),
-    processSearchResult: (elements, useLessLoopConfig, { config, dataflow, normalize, cfg }) => {
+    processSearchResult: (elements, useLessLoopConfig, { analyzer, dataflow, normalize, cfg }) => {
         const results = elements.getElements().filter(e => {
             const vertex = dataflow.graph.getVertex(e.node.info.id);
             return vertex
                 && (0, vertex_1.isFunctionCallVertex)(vertex)
                 && vertex.origin !== 'unnamed'
                 && useLessLoopConfig.loopyFunctions.has(vertex.origin[0]);
-        }).filter(loop => (0, useless_loop_1.onlyLoopsOnce)(loop.node.info.id, dataflow.graph, cfg, normalize, config)).map(res => ({
+        }).filter(loop => (0, useless_loop_1.onlyLoopsOnce)(loop.node.info.id, dataflow.graph, cfg, normalize, analyzer.inspectContext())).map(res => ({
             certainty: linter_format_1.LintingResultCertainty.Certain,
             name: res.node.lexeme,
             range: res.node.info.fullRange

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/flowr",
-  "version": "2.6.2",
+  "version": "2.7.0",
   "description": "Static Dataflow Analyzer and Program Slicer for the R Programming Language",
   "types": "dist/src/index.d.ts",
   "repository": {
@@ -25,22 +25,9 @@
     "benchmark": "npm run build-dev && node dist/src/cli/benchmark-app.js",
     "summarizer": "ts-node src/cli/summarizer-app.ts",
     "export-quads": "ts-node src/cli/export-quads-app.ts",
-    "capabilities-markdown": "ts-node src/documentation/print-capabilities-markdown.ts",
-    "wiki:df-graph": "ts-node src/documentation/print-dataflow-graph-wiki.ts",
-    "wiki:normalized-ast": "ts-node src/documentation/print-normalized-ast-wiki.ts",
-    "wiki:query-api": "ts-node src/documentation/print-query-wiki.ts",
-    "wiki:core": "ts-node src/documentation/print-core-wiki.ts",
-    "wiki:analyzer": "ts-node src/documentation/print-analyzer-wiki.ts",
-    "wiki:engines": "ts-node src/documentation/print-engines-wiki.ts",
-    "wiki:search-api": "ts-node src/documentation/print-search-wiki.ts",
-    "wiki:linting-and-testing": "ts-node src/documentation/print-linting-and-testing-wiki.ts",
-    "wiki:interface": "ts-node src/documentation/print-interface-wiki.ts",
-    "wiki:onboarding": "ts-node src/documentation/print-onboarding-wiki.ts",
-    "wiki:faq": "ts-node src/documentation/print-faq-wiki.ts",
-    "wiki:cfg": "ts-node src/documentation/print-cfg-wiki.ts",
-    "wiki:linter": "ts-node src/documentation/print-linter-wiki.ts",
-    "gen:readme": "ts-node src/documentation/print-readme.ts",
-    "gen:linter-issue": "ts-node src/documentation/print-linter-issue.ts",
+    "capabilities-markdown": "ts-node src/documentation/doc-capabilities.ts",
+    "wiki": "ts-node src/cli/wiki.ts",
+    "wiki:watch": "ts-node-dev src/cli/wiki.ts -- --keep-alive",
     "build": "tsc --project .",
     "build-dev": "npm run build && npm run build:copy-wasm",
     "build:bundle-flowr": "npm run build && esbuild --bundle dist/src/cli/flowr.js --platform=node --tree-shaking=true --bundle --minify --external:clipboardy --target=node22 --outfile=dist/src/cli/flowr.min.js && npm run build:copy-wasm",
@@ -210,6 +197,7 @@
   },
   "dependencies": {
     "@eagleoutice/tree-sitter-r": "^1.1.2",
+    "@jupyterlab/nbformat": "^4.5.0",
     "@xmldom/xmldom": "^0.9.7",
     "clipboardy": "^4.0.0",
     "command-line-args": "^6.0.1",

package/project/cache/flowr-analyzer-cache.d.ts

@@ -1,21 +1,18 @@
 import type { KnownParser } from '../../r-bridge/parser';
 import { type CacheInvalidationEvent, FlowrCache } from './flowr-cache';
 import { type DEFAULT_DATAFLOW_PIPELINE, type TREE_SITTER_DATAFLOW_PIPELINE } from '../../core/steps/pipeline/default-pipelines';
-import type { FlowrConfigOptions } from '../../config';
-import type { RParseRequests } from '../../r-bridge/retriever';
 import type { IdGenerator } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { NoInfo } from '../../r-bridge/lang-4.x/ast/model/model';
 import type { TreeSitterExecutor } from '../../r-bridge/lang-4.x/tree-sitter/tree-sitter-executor';
 import type { PipelineOutput } from '../../core/steps/pipeline/pipeline';
 import type { CfgSimplificationPassName } from '../../control-flow/cfg-simplification';
 import type { ControlFlowInformation } from '../../control-flow/control-flow-graph';
-import { CfgKind } from '../cfg-kind';
+import type { CfgKind } from '../cfg-kind';
+import type { FlowrAnalyzerContext } from '../context/flowr-analyzer-context';
 interface FlowrAnalyzerCacheOptions<Parser extends KnownParser> {
     parser: Parser;
-    config: FlowrConfigOptions;
-    request: RParseRequests;
+    context: FlowrAnalyzerContext;
     getId?: IdGenerator<NoInfo>;
-    overwriteFilePath?: string;
 }
 export type AnalyzerCacheType<Parser extends KnownParser> = Parser extends TreeSitterExecutor ? Partial<PipelineOutput<typeof TREE_SITTER_DATAFLOW_PIPELINE>> : Partial<PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>>;
 /**
@@ -71,14 +68,14 @@ export declare class FlowrAnalyzerCache<Parser extends KnownParser> extends Flow
     peekDataflow(): NonNullable<AnalyzerCacheType<Parser>['dataflow']> | undefined;
     /**
      * Get the control flow graph (CFG) for the request, computing if necessary.
-     * @param force - Do not use the cache, instead force new analyses.
-     * @param kind - The kind of CFG that is requested.
+     * @param force           - Do not use the cache, instead force new analyses.
+     * @param kind            - The kind of CFG that is requested.
      * @param simplifications - Simplification passes to be applied to the CFG.
      */
-    controlflow(force: boolean | undefined, kind: CfgKind, simplifications: readonly CfgSimplificationPassName[] | undefined): Promise<ControlFlowInformation>;
+    controlflow(force: boolean | undefined, kind: CfgKind, simplifications?: readonly CfgSimplificationPassName[]): Promise<ControlFlowInformation>;
     /**
      * Get the control flow graph (CFG) for the request if already available, otherwise return `undefined`.
-     * @param kind - The kind of CFG that is requested.
+     * @param kind            - The kind of CFG that is requested.
      * @param simplifications - Simplification passes to be applied to the CFG.
      * @see {@link FlowrAnalyzerCache#controlflow} - to get the control flow graph, computing if necessary.
      */

package/project/cache/flowr-analyzer-cache.js

@@ -4,9 +4,7 @@ exports.FlowrAnalyzerCache = void 0;
 const flowr_cache_1 = require("./flowr-cache");
 const default_pipelines_1 = require("../../core/steps/pipeline/default-pipelines");
 const assert_1 = require("../../util/assert");
-const objectmap_1 = require("../../util/collections/objectmap");
-const extract_cfg_1 = require("../../control-flow/extract-cfg");
-const cfg_kind_1 = require("../cfg-kind");
+const flowr_analyzer_controlflow_cache_1 = require("./flowr-analyzer-controlflow-cache");
 /**
  * This provides the full analyzer caching layer, please avoid using this directly
  * and prefer the {@link FlowrAnalyzer}.
@@ -22,13 +20,10 @@ class FlowrAnalyzerCache extends flowr_cache_1.FlowrCache {
     }
     initCacheProviders() {
         this.pipeline = (0, default_pipelines_1.createDataflowPipeline)(this.args.parser, {
-            request: this.args.request,
-            getId: this.args.getId,
-            overwriteFilePath: this.args.overwriteFilePath
-        }, this.args.config);
-        this.controlFlowCache = {
-            simplified: new objectmap_1.ObjectMap(),
-        };
+            context: this.args.context,
+            getId: this.args.getId
+        });
+        this.controlFlowCache = new flowr_analyzer_controlflow_cache_1.FlowrAnalyzerControlFlowCache();
     }
     static create(data) {
         return new FlowrAnalyzerCache(data);
@@ -51,7 +46,7 @@ class FlowrAnalyzerCache extends flowr_cache_1.FlowrCache {
         this.receive({ type: "full" /* CacheInvalidationEventType.Full */ });
     }
     async runTapeUntil(force, until) {
-        (0, assert_1.guard)(this.args.request && (Array.isArray(this.args.request) ? this.args.request.length > 0 : true), 'At least one request must be set to run the analysis pipeline');
+        (0, assert_1.guard)(this.args.context.files.loadingOrder.getUnorderedRequests().length > 0, 'At least one request must be set to run the analysis pipeline');
         if (force) {
             this.reset();
         }
@@ -115,43 +110,27 @@ class FlowrAnalyzerCache extends flowr_cache_1.FlowrCache {
     }
     /**
      * Get the control flow graph (CFG) for the request, computing if necessary.
-     * @param force - Do not use the cache, instead force new analyses.
-     * @param kind - The kind of CFG that is requested.
+     * @param force           - Do not use the cache, instead force new analyses.
+     * @param kind            - The kind of CFG that is requested.
      * @param simplifications - Simplification passes to be applied to the CFG.
      */
     async controlflow(force, kind, simplifications) {
-        (0, assert_1.guard)(kind === cfg_kind_1.CfgKind.Quick ? simplifications === undefined : true, 'Cannot apply simplifications to quick CFG');
-        simplifications ??= [];
-        if (!force) {
-            const value = this.controlFlowCache.simplified.get([simplifications, kind]);
-            if (value !== undefined) {
-                return value;
-            }
-        }
-        const normalized = await this.normalize(force);
-        let result;
-        switch (kind) {
-            case cfg_kind_1.CfgKind.WithDataflow:
-                result = (0, extract_cfg_1.extractCfg)(normalized, this.args.config, (await this.dataflow()).graph, simplifications);
-                break;
-            case cfg_kind_1.CfgKind.NoDataflow:
-                result = (0, extract_cfg_1.extractCfg)(normalized, this.args.config, undefined, simplifications);
-                break;
-            case cfg_kind_1.CfgKind.Quick:
-                result = this.peekDataflow()?.cfgQuick ?? (0, extract_cfg_1.extractCfgQuick)(normalized);
-                break;
-        }
-        this.controlFlowCache.simplified.set([simplifications, kind], result);
-        return result;
+        const cfgInfo = {
+            ctx: this.args.context,
+            cfgQuick: this.peekDataflow()?.cfgQuick,
+            ast: async () => await this.normalize(),
+            dfg: async () => await this.dataflow()
+        };
+        return this.controlFlowCache.get(force, kind, cfgInfo, simplifications);
     }
     /**
      * Get the control flow graph (CFG) for the request if already available, otherwise return `undefined`.
-     * @param kind - The kind of CFG that is requested.
+     * @param kind            - The kind of CFG that is requested.
      * @param simplifications - Simplification passes to be applied to the CFG.
      * @see {@link FlowrAnalyzerCache#controlflow} - to get the control flow graph, computing if necessary.
      */
     peekControlflow(kind, simplifications) {
-        return this.controlFlowCache.simplified.get([simplifications ?? [], kind]);
+        return this.controlFlowCache.peek(kind, simplifications);
     }
 }
 exports.FlowrAnalyzerCache = FlowrAnalyzerCache;

package/project/cache/flowr-analyzer-controlflow-cache.d.ts

@@ -0,0 +1,34 @@
+import type { CfgSimplificationPassName } from '../../control-flow/cfg-simplification';
+import { CfgKind } from '../cfg-kind';
+import type { ControlFlowInformation } from '../../control-flow/control-flow-graph';
+import type { NormalizedAst } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { DataflowInformation } from '../../dataflow/info';
+import type { FlowrAnalyzerContext } from '../context/flowr-analyzer-context';
+interface CfgInfo {
+    ctx: FlowrAnalyzerContext;
+    cfgQuick: ControlFlowInformation | undefined;
+    dfg: () => Promise<DataflowInformation>;
+    ast: () => Promise<NormalizedAst>;
+}
+export declare class FlowrAnalyzerControlFlowCache {
+    private readonly cache;
+    peek(kind: CfgKind, simplifications: readonly CfgSimplificationPassName[] | undefined): ControlFlowInformation | undefined;
+    get(force: boolean | undefined, kind: CfgKind, cfgCacheInfo: CfgInfo, simplifications?: readonly CfgSimplificationPassName[]): Promise<ControlFlowInformation>;
+    /**
+     * Create and cache the base CFG without simplifications.
+     */
+    private createAndCacheBaseCfg;
+    /**
+     * Try to get a cached CFG with some of the requested simplifications already applied.
+     * Matches the longest prefix of simplifications available.
+     * @returns The cached CFG and the missing simplifications to be applied, or `undefined` if no cached CFG is available.
+     */
+    private tryGetCachedCfg;
+    /**
+     * Normalize the order of simplification passes.
+     * Is currently an identity function, but may be extended in the future to enforce a specific order using heuristics.
+     * @param simplifications - the requested simplification passes.
+     */
+    private normalizeSimplificationOrder;
+}
+export {};

package/project/cache/flowr-analyzer-controlflow-cache.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrAnalyzerControlFlowCache = void 0;
+const objectmap_1 = require("../../util/collections/objectmap");
+const cfg_simplification_1 = require("../../control-flow/cfg-simplification");
+const cfg_kind_1 = require("../cfg-kind");
+const assert_1 = require("../../util/assert");
+const extract_cfg_1 = require("../../control-flow/extract-cfg");
+class FlowrAnalyzerControlFlowCache {
+    cache = new objectmap_1.ObjectMap();
+    peek(kind, simplifications) {
+        return this.cache.get([simplifications ?? [], kind]);
+    }
+    async get(force, kind, cfgCacheInfo, simplifications) {
+        (0, assert_1.guard)(kind === cfg_kind_1.CfgKind.Quick ? simplifications === undefined : true, 'Cannot apply simplifications to quick CFG');
+        simplifications ??= [];
+        const orderedSimplifications = this.normalizeSimplificationOrder(simplifications);
+        const cached = force ?
+            { cfg: undefined, missingSimplifications: orderedSimplifications }
+            : this.tryGetCachedCfg(orderedSimplifications, kind);
+        let cfg = cached.cfg;
+        if (!cfg) {
+            cfg = await this.createAndCacheBaseCfg(kind, cfgCacheInfo);
+        }
+        if (cached.missingSimplifications.length > 0) {
+            const cfgPassInfo = { dfg: (await cfgCacheInfo.dfg()).graph, ctx: cfgCacheInfo.ctx, ast: await cfgCacheInfo.ast() };
+            cfg = (0, cfg_simplification_1.simplifyControlFlowInformation)(cfg, cfgPassInfo, cached.missingSimplifications);
+        }
+        this.cache.set([orderedSimplifications, kind], cfg);
+        return cfg;
+    }
+    /**
+     * Create and cache the base CFG without simplifications.
+     */
+    async createAndCacheBaseCfg(kind, { cfgQuick, dfg, ctx, ast }) {
+        let result;
+        switch (kind) {
+            case cfg_kind_1.CfgKind.WithDataflow:
+                result = (0, extract_cfg_1.extractCfg)(await ast(), ctx, (await dfg()).graph);
+                break;
+            case cfg_kind_1.CfgKind.NoDataflow:
+                result = (0, extract_cfg_1.extractCfg)(await ast(), ctx);
+                break;
+            case cfg_kind_1.CfgKind.Quick:
+                result = cfgQuick ?? (0, extract_cfg_1.extractCfgQuick)(await ast());
+                break;
+        }
+        this.cache.set([[], kind], result);
+        return result;
+    }
+    /**
+     * Try to get a cached CFG with some of the requested simplifications already applied.
+     * Matches the longest prefix of simplifications available.
+     * @returns The cached CFG and the missing simplifications to be applied, or `undefined` if no cached CFG is available.
+     */
+    tryGetCachedCfg(simplifications, kind) {
+        for (let prefixLen = simplifications.length; prefixLen >= 0; prefixLen--) {
+            const prefix = simplifications.slice(0, prefixLen);
+            const cached = this.cache.get([prefix, kind]);
+            if (cached !== undefined) {
+                return {
+                    cfg: cached,
+                    missingSimplifications: simplifications.slice(prefixLen)
+                };
+            }
+        }
+        return { cfg: undefined, missingSimplifications: simplifications };
+    }
+    /**
+     * Normalize the order of simplification passes.
+     * Is currently an identity function, but may be extended in the future to enforce a specific order using heuristics.
+     * @param simplifications - the requested simplification passes.
+     */
+    normalizeSimplificationOrder(simplifications) {
+        return simplifications;
+    }
+}
+exports.FlowrAnalyzerControlFlowCache = FlowrAnalyzerControlFlowCache;
+//# sourceMappingURL=flowr-analyzer-controlflow-cache.js.map