@eagleoutice/flowr 2.6.0 → 2.6.1

package/cli/repl/commands/repl-version.js

@@ -1,30 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.versionCommand = void 0;
-exports.retrieveVersionInformation = retrieveVersionInformation;
-exports.printVersionInformation = printVersionInformation;
 const version_1 = require("../../../util/version");
-const assert_1 = require("../../../util/assert");
-const versionRegex = /^\d+\.\d+\.\d+/m;
-async function retrieveVersionInformation(parser) {
-    const flowr = (0, version_1.flowrVersion)().toString();
-    const r = await parser.rVersion();
-    (0, assert_1.guard)(versionRegex.test(flowr), `flowR version ${flowr} does not match the expected format!`);
-    (0, assert_1.guard)(r === 'unknown' || r === 'none' || versionRegex.test(r), `R version ${r} does not match the expected format!`);
-    return { flowr: flowr, r: r, engine: parser.name };
-}
-async function printVersionInformation(output, parser) {
-    const { flowr, r, engine } = await retrieveVersionInformation(parser);
-    output.stdout(`Engine: ${engine}`);
-    output.stdout(` flowR: ${flowr}`);
-    output.stdout(` R: ${r}`);
-}
 exports.versionCommand = {
     description: 'Prints the version of flowR as well as the current version of R',
-    usesAnalyzer: false,
+    isCodeCommand: false,
     aliases: [],
     usageExample: ':version',
     script: false,
-    fn: ({ output, parser }) => printVersionInformation(output, parser)
+    fn: ({ output, analyzer }) => (0, version_1.printVersionInformation)(output, analyzer)
 };
 //# sourceMappingURL=repl-version.js.map

package/cli/repl/core.d.ts

@@ -1,33 +1,34 @@
 import * as readline from 'readline';
 import type { ReplOutput } from './commands/repl-main';
 import type { MergeableRecord } from '../../util/objects';
-import type { KnownParser } from '../../r-bridge/parser';
 import type { FlowrConfigOptions } from '../../config';
+import type { FlowrAnalyzer } from '../../project/flowr-analyzer';
 /**
  * Used by the repl to provide automatic completions for a given (partial) input line
  */
 export declare function replCompleter(line: string, config: FlowrConfigOptions): [string[], string];
 export declare function makeDefaultReplReadline(config: FlowrConfigOptions): readline.ReadLineOptions;
 export declare function handleString(code: string): {
-    input: string;
+    input: string | undefined;
     remaining: never[];
 };
 /**
  * This function interprets the given `expr` as a REPL command (see {@link repl} for more on the semantics).
  *
- * @param config              - flowr Config
+ * @param analyzer            - The flowR analyzer to use.
  * @param output              - Defines two methods that every function in the repl uses to output its data.
  * @param expr                - The expression to process.
- * @param parser               - The {@link RShell} or {@link TreeSitterExecutor} to use (see {@link repl}).
  * @param allowRSessionAccess - If true, allows the execution of arbitrary R code.
  */
-export declare function replProcessAnswer(config: FlowrConfigOptions, output: ReplOutput, expr: string, parser: KnownParser, allowRSessionAccess: boolean): Promise<void>;
+export declare function replProcessAnswer(analyzer: FlowrAnalyzer, output: ReplOutput, expr: string, allowRSessionAccess: boolean): Promise<void>;
 /**
  * Options for the {@link repl} function.
  */
 export interface FlowrReplOptions extends MergeableRecord {
-    /** The shell to use, if you do not pass one it will automatically create a new one with the `revive` option set to 'always'. */
-    readonly parser?: KnownParser;
+    /**
+     * The flowR analyzer to use.
+     */
+    readonly analyzer: FlowrAnalyzer;
     /**
      * A potentially customized readline interface to be used for the repl to *read* from the user, we write the output with the {@link ReplOutput | `output` } interface.
     * If you want to provide a custom one but use the same `completer`, refer to {@link replCompleter}.
@@ -48,10 +49,9 @@ export interface FlowrReplOptions extends MergeableRecord {
  * - Starting with anything else, indicating default R code to be directly executed. If you kill the underlying shell, that is on you! </li>
  *
  * @param options - The options for the repl. See {@link FlowrReplOptions} for more information.
- * @param config  - The flowr config
  *
  * For the execution, this function makes use of {@link replProcessAnswer}.
  *
  */
-export declare function repl(config: FlowrConfigOptions, { parser, rl, output, historyFile, allowRSessionAccess }: FlowrReplOptions): Promise<void>;
+export declare function repl({ analyzer, rl, output, historyFile, allowRSessionAccess }: FlowrReplOptions): Promise<void>;
 export declare function loadReplHistory(historyFile: string): string[] | undefined;

package/cli/repl/core.js

@@ -58,11 +58,8 @@ const repl_commands_1 = require("./commands/repl-commands");
 const scripts_info_1 = require("../common/scripts-info");
 const retriever_1 = require("../../r-bridge/retriever");
 const repl_main_1 = require("./commands/repl-main");
-const shell_1 = require("../../r-bridge/shell");
 const log_1 = require("../../util/log");
-const config_1 = require("../../config");
 const query_1 = require("../../queries/query");
-const flowr_analyzer_builder_1 = require("../../project/flowr-analyzer-builder");
 let _replCompleterKeywords = undefined;
 function replCompleterKeywords() {
     if (_replCompleterKeywords === undefined) {
@@ -133,11 +130,11 @@ function makeDefaultReplReadline(config) {
 }
 function handleString(code) {
     return {
-        input: code.startsWith('"') ? JSON.parse(code) : code,
+        input: code.length == 0 ? undefined : code.startsWith('"') ? JSON.parse(code) : code,
         remaining: []
     };
 }
-async function replProcessStatement(output, statement, parser, allowRSessionAccess, config) {
+async function replProcessStatement(output, statement, analyzer, allowRSessionAccess) {
     if (statement.startsWith(':')) {
         const command = statement.slice(1).split(' ')[0].toLowerCase();
         const processor = (0, repl_commands_1.getCommand)(command);
@@ -145,17 +142,16 @@ async function replProcessStatement(output, statement, parser, allowRSessionAcce
         if (processor) {
             try {
                 const remainingLine = statement.slice(command.length + 2).trim();
-                if (processor.usesAnalyzer) {
+                if (processor.isCodeCommand) {
                     const args = processor.argsParser(remainingLine);
-                    const request = (0, retriever_1.requestFromInput)(args.input);
-                    const analyzer = await new flowr_analyzer_builder_1.FlowrAnalyzerBuilder(request)
-                        .setConfig(config)
-                        .setParser(parser)
-                        .build();
+                    if (args.input) {
+                        analyzer.reset();
+                        analyzer.context().addRequest((0, retriever_1.requestFromInput)(args.input));
+                    }
                     await processor.fn({ output, analyzer, remainingArgs: args.remaining });
                 }
                 else {
-                    await processor.fn({ output, parser, remainingLine, allowRSessionAccess, config });
+                    await processor.fn({ output, analyzer, remainingLine, allowRSessionAccess });
                 }
             }
             catch (e) {
@@ -170,22 +166,21 @@ async function replProcessStatement(output, statement, parser, allowRSessionAcce
         }
     }
     else {
-        await (0, repl_execute_1.tryExecuteRShellCommand)({ output, parser, remainingLine: statement, allowRSessionAccess, config });
+        await (0, repl_execute_1.tryExecuteRShellCommand)({ output, analyzer, remainingLine: statement, allowRSessionAccess });
     }
 }
 /**
  * This function interprets the given `expr` as a REPL command (see {@link repl} for more on the semantics).
  *
- * @param config              - flowr Config
+ * @param analyzer            - The flowR analyzer to use.
  * @param output              - Defines two methods that every function in the repl uses to output its data.
  * @param expr                - The expression to process.
- * @param parser               - The {@link RShell} or {@link TreeSitterExecutor} to use (see {@link repl}).
  * @param allowRSessionAccess - If true, allows the execution of arbitrary R code.
  */
-async function replProcessAnswer(config, output, expr, parser, allowRSessionAccess) {
+async function replProcessAnswer(analyzer, output, expr, allowRSessionAccess) {
     const statements = (0, args_1.splitAtEscapeSensitive)(expr, false, ';');
     for (const statement of statements) {
-        await replProcessStatement(output, statement, parser, allowRSessionAccess, config);
+        await replProcessStatement(output, statement, analyzer, allowRSessionAccess);
     }
 }
 /**
@@ -196,12 +191,11 @@ async function replProcessAnswer(config, output, expr, parser, allowRSessionAcce
  * - Starting with anything else, indicating default R code to be directly executed. If you kill the underlying shell, that is on you! </li>
  *
  * @param options - The options for the repl. See {@link FlowrReplOptions} for more information.
- * @param config  - The flowr config
  *
  * For the execution, this function makes use of {@link replProcessAnswer}.
  *
  */
-async function repl(config, { parser = new shell_1.RShell((0, config_1.getEngineConfig)(config, 'r-shell'), { revive: 2 /* RShellReviveOptions.Always */ }), rl = readline.createInterface(makeDefaultReplReadline(config)), output = repl_main_1.standardReplOutput, historyFile = defaultHistoryFile, allowRSessionAccess = false }) {
+async function repl({ analyzer, rl = readline.createInterface(makeDefaultReplReadline(analyzer.flowrConfig)), output = repl_main_1.standardReplOutput, historyFile = defaultHistoryFile, allowRSessionAccess = false }) {
     if (historyFile) {
         rl.on('history', h => fs_1.default.writeFileSync(historyFile, h.join('\n'), { encoding: 'utf-8' }));
     }
@@ -210,7 +204,7 @@ async function repl(config, { parser = new shell_1.RShell((0, config_1.getEngine
         await new Promise((resolve, reject) => {
             rl.question((0, prompt_1.prompt)(), answer => {
                 rl.pause();
-                replProcessAnswer(config, output, answer, parser, allowRSessionAccess).then(() => {
+                replProcessAnswer(analyzer, output, answer, allowRSessionAccess).then(() => {
                     rl.resume();
                     resolve();
                 }).catch(reject);

package/cli/repl/print-version.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.versionReplString = versionReplString;
 exports.printVersionRepl = printVersionRepl;
-const repl_version_1 = require("./commands/repl-version");
+const version_1 = require("../../util/version");
 async function versionReplString(parser) {
-    const version = await (0, repl_version_1.retrieveVersionInformation)(parser);
+    const version = await (0, version_1.retrieveVersionInformation)(parser);
     const rVersion = version.r === 'none' ? '' : version.r === 'unknown' ? ', R version unknown' : `, R v${version.r}`;
     const treeSitterVer = parser.name === 'tree-sitter' ? `, R grammar v${parser.treeSitterVersion()}` : '';
     return `flowR repl using flowR v${version.flowr}${rVersion}${treeSitterVer} (${version.engine} engine)`;

package/cli/repl/server/connection.js

@@ -287,11 +287,15 @@ class FlowRServerConnection {
                 stream
             });
         };
-        void (0, core_1.replProcessAnswer)(this.config, {
+        const analyzer = new flowr_analyzer_builder_1.FlowrAnalyzerBuilder()
+            .setConfig(this.config)
+            .setParser(this.parser)
+            .buildSync();
+        void (0, core_1.replProcessAnswer)(analyzer, {
             formatter: request.ansi ? ansi_1.ansiFormatter : ansi_1.voidFormatter,
             stdout: msg => out('stdout', msg),
             stderr: msg => out('stderr', msg)
-        }, request.expression, this.parser, this.allowRSessionAccess).then(() => {
+        }, request.expression, this.allowRSessionAccess).then(() => {
             (0, send_1.sendMessage)(this.socket, {
                 type: 'end-repl-execution',
                 id: request.id

package/cli/repl/server/messages/message-hello.d.ts

@@ -1,5 +1,5 @@
-import type { VersionInformation } from '../../commands/repl-version';
 import type { IdMessageBase, MessageDefinition } from './all-messages';
+import type { VersionInformation } from '../../../../util/version';
 /**
  * The hello message is automatically sent by the sever upon connection.
  */

package/cli/repl/server/server.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowRServer = exports.serverLog = void 0;
-const repl_version_1 = require("../commands/repl-version");
 const connection_1 = require("./connection");
 const send_1 = require("./send");
 const net_1 = require("./net");
 const log_1 = require("../../../util/log");
+const version_1 = require("../../../util/version");
 // we detach from the main logger so that it can have its own switch
 exports.serverLog = new log_1.FlowrLogger({ name: 'server' });
 /**
@@ -32,7 +32,7 @@ class FlowRServer {
         this.config = config;
     }
     async start(port) {
-        this.versionInformation = await (0, repl_version_1.retrieveVersionInformation)(this.engines[this.defaultEngine]);
+        this.versionInformation = await (0, version_1.retrieveVersionInformation)(this.engines[this.defaultEngine]);
         this.server.start(port);
         exports.serverLog.info(`Server listening on port ${port}`);
     }

package/core/steps/all/core/20-dataflow.d.ts

@@ -10,7 +10,9 @@ declare function processor(results: {
 }, input: {
     request?: RParseRequests;
     parser?: Parser<KnownParserType>;
-}, config: FlowrConfigOptions): import("../../../../dataflow/info").DataflowInformation;
+}, config: FlowrConfigOptions): import("../../../../dataflow/info").DataflowInformation & {
+    cfgQuick: import("../../../../control-flow/control-flow-graph").ControlFlowInformation | undefined;
+};
 export declare const STATIC_DATAFLOW: {
     readonly humanReadableName: "dataflow";
     readonly processor: typeof processor;

package/core/steps/pipeline/default-pipelines.d.ts

@@ -8,6 +8,20 @@ import type { RShell } from '../../../r-bridge/shell';
 import type { TreeSitterExecutor } from '../../../r-bridge/lang-4.x/tree-sitter/tree-sitter-executor';
 import type { FlowrConfigOptions } from '../../../config';
 export declare const DEFAULT_SLICING_PIPELINE: import("./pipeline").Pipeline<{
+    readonly name: "slice";
+    readonly humanReadableName: "static slice";
+    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
+    readonly processor: (results: {
+        dataflow?: import("../../../dataflow/info").DataflowInformation;
+        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>, _config: FlowrConfigOptions) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+    };
+    readonly dependencies: readonly ["dataflow"];
+    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
+} | {
     readonly name: "parse";
     readonly humanReadableName: "parse with R shell";
     readonly description: "Parse the given R code into an AST";
@@ -40,20 +54,6 @@ export declare const DEFAULT_SLICING_PIPELINE: import("./pipeline").Pipeline<{
     };
     readonly dependencies: readonly ["parse"];
     readonly requiredInput: import("../all/core/10-normalize").NormalizeRequiredInput;
-} | {
-    readonly name: "slice";
-    readonly humanReadableName: "static slice";
-    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
-    readonly processor: (results: {
-        dataflow?: import("../../../dataflow/info").DataflowInformation;
-        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
-    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>, _config: FlowrConfigOptions) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
-    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
-    readonly printer: {
-        readonly 0: typeof import("../../print/print").internalPrinter;
-    };
-    readonly dependencies: readonly ["dataflow"];
-    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
 } | {
     readonly humanReadableName: "dataflow";
     readonly processor: (results: {
@@ -61,7 +61,9 @@ export declare const DEFAULT_SLICING_PIPELINE: import("./pipeline").Pipeline<{
     }, input: {
         request?: import("../../../r-bridge/retriever").RParseRequests;
         parser?: Parser<import("../../../r-bridge/parser").KnownParserType>;
-    }, config: FlowrConfigOptions) => import("../../../dataflow/info").DataflowInformation;
+    }, config: FlowrConfigOptions) => import("../../../dataflow/info").DataflowInformation & {
+        cfgQuick: import("../../../control-flow/control-flow-graph").ControlFlowInformation | undefined;
+    };
     readonly requiredInput: {};
     readonly name: "dataflow";
     readonly description: "Construct the dataflow graph";
@@ -90,6 +92,20 @@ export declare const DEFAULT_SLICING_PIPELINE: import("./pipeline").Pipeline<{
     readonly requiredInput: import("../all/static-slicing/10-reconstruct").ReconstructRequiredInput;
 }>;
 export declare const DEFAULT_SLICE_AND_RECONSTRUCT_PIPELINE: import("./pipeline").Pipeline<{
+    readonly name: "slice";
+    readonly humanReadableName: "static slice";
+    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
+    readonly processor: (results: {
+        dataflow?: import("../../../dataflow/info").DataflowInformation;
+        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>, _config: FlowrConfigOptions) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+    };
+    readonly dependencies: readonly ["dataflow"];
+    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
+} | {
     readonly name: "parse";
     readonly humanReadableName: "parse with R shell";
     readonly description: "Parse the given R code into an AST";
@@ -122,20 +138,6 @@ export declare const DEFAULT_SLICE_AND_RECONSTRUCT_PIPELINE: import("./pipeline"
     };
     readonly dependencies: readonly ["parse"];
     readonly requiredInput: import("../all/core/10-normalize").NormalizeRequiredInput;
-} | {
-    readonly name: "slice";
-    readonly humanReadableName: "static slice";
-    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
-    readonly processor: (results: {
-        dataflow?: import("../../../dataflow/info").DataflowInformation;
-        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
-    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>, _config: FlowrConfigOptions) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
-    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
-    readonly printer: {
-        readonly 0: typeof import("../../print/print").internalPrinter;
-    };
-    readonly dependencies: readonly ["dataflow"];
-    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
 } | {
     readonly humanReadableName: "dataflow";
     readonly processor: (results: {
@@ -143,7 +145,9 @@ export declare const DEFAULT_SLICE_AND_RECONSTRUCT_PIPELINE: import("./pipeline"
     }, input: {
         request?: import("../../../r-bridge/retriever").RParseRequests;
         parser?: Parser<import("../../../r-bridge/parser").KnownParserType>;
-    }, config: FlowrConfigOptions) => import("../../../dataflow/info").DataflowInformation;
+    }, config: FlowrConfigOptions) => import("../../../dataflow/info").DataflowInformation & {
+        cfgQuick: import("../../../control-flow/control-flow-graph").ControlFlowInformation | undefined;
+    };
     readonly requiredInput: {};
     readonly name: "dataflow";
     readonly description: "Construct the dataflow graph";
@@ -172,6 +176,20 @@ export declare const DEFAULT_SLICE_AND_RECONSTRUCT_PIPELINE: import("./pipeline"
     readonly requiredInput: import("../all/static-slicing/10-reconstruct").ReconstructRequiredInput;
 }>;
 export declare const DEFAULT_SLICE_WITHOUT_RECONSTRUCT_PIPELINE: import("./pipeline").Pipeline<{
+    readonly name: "slice";
+    readonly humanReadableName: "static slice";
+    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
+    readonly processor: (results: {
+        dataflow?: import("../../../dataflow/info").DataflowInformation;
+        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>, _config: FlowrConfigOptions) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+    };
+    readonly dependencies: readonly ["dataflow"];
+    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
+} | {
     readonly name: "parse";
     readonly humanReadableName: "parse with R shell";
     readonly description: "Parse the given R code into an AST";
@@ -204,20 +222,6 @@ export declare const DEFAULT_SLICE_WITHOUT_RECONSTRUCT_PIPELINE: import("./pipel
     };
     readonly dependencies: readonly ["parse"];
     readonly requiredInput: import("../all/core/10-normalize").NormalizeRequiredInput;
-} | {
-    readonly name: "slice";
-    readonly humanReadableName: "static slice";
-    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
-    readonly processor: (results: {
-        dataflow?: import("../../../dataflow/info").DataflowInformation;
-        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
-    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>, _config: FlowrConfigOptions) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
-    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
-    readonly printer: {
-        readonly 0: typeof import("../../print/print").internalPrinter;
-    };
-    readonly dependencies: readonly ["dataflow"];
-    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
 } | {
     readonly humanReadableName: "dataflow";
     readonly processor: (results: {
@@ -225,7 +229,9 @@ export declare const DEFAULT_SLICE_WITHOUT_RECONSTRUCT_PIPELINE: import("./pipel
     }, input: {
         request?: import("../../../r-bridge/retriever").RParseRequests;
         parser?: Parser<import("../../../r-bridge/parser").KnownParserType>;
-    }, config: FlowrConfigOptions) => import("../../../dataflow/info").DataflowInformation;
+    }, config: FlowrConfigOptions) => import("../../../dataflow/info").DataflowInformation & {
+        cfgQuick: import("../../../control-flow/control-flow-graph").ControlFlowInformation | undefined;
+    };
     readonly requiredInput: {};
     readonly name: "dataflow";
     readonly description: "Construct the dataflow graph";
@@ -260,7 +266,9 @@ export declare const TREE_SITTER_SLICING_PIPELINE: import("./pipeline").Pipeline
     }, input: {
         request?: import("../../../r-bridge/retriever").RParseRequests;
         parser?: Parser<import("../../../r-bridge/parser").KnownParserType>;
-    }, config: FlowrConfigOptions) => import("../../../dataflow/info").DataflowInformation;
+    }, config: FlowrConfigOptions) => import("../../../dataflow/info").DataflowInformation & {
+        cfgQuick: import("../../../control-flow/control-flow-graph").ControlFlowInformation | undefined;
+    };
     readonly requiredInput: {};
     readonly name: "dataflow";
     readonly description: "Construct the dataflow graph";
@@ -341,7 +349,9 @@ export declare const TREE_SITTER_SLICE_AND_RECONSTRUCT_PIPELINE: import("./pipel
     }, input: {
         request?: import("../../../r-bridge/retriever").RParseRequests;
         parser?: Parser<import("../../../r-bridge/parser").KnownParserType>;
-    }, config: FlowrConfigOptions) => import("../../../dataflow/info").DataflowInformation;
+    }, config: FlowrConfigOptions) => import("../../../dataflow/info").DataflowInformation & {
+        cfgQuick: import("../../../control-flow/control-flow-graph").ControlFlowInformation | undefined;
+    };
     readonly requiredInput: {};
     readonly name: "dataflow";
     readonly description: "Construct the dataflow graph";
@@ -422,7 +432,9 @@ export declare const TREE_SITTER_SLICE_WITHOUT_RECONSTRUCT_PIPELINE: import("./p
     }, input: {
         request?: import("../../../r-bridge/retriever").RParseRequests;
         parser?: Parser<import("../../../r-bridge/parser").KnownParserType>;
-    }, config: FlowrConfigOptions) => import("../../../dataflow/info").DataflowInformation;
+    }, config: FlowrConfigOptions) => import("../../../dataflow/info").DataflowInformation & {
+        cfgQuick: import("../../../control-flow/control-flow-graph").ControlFlowInformation | undefined;
+    };
     readonly requiredInput: {};
     readonly name: "dataflow";
     readonly description: "Construct the dataflow graph";
@@ -513,7 +525,9 @@ export declare const DEFAULT_DATAFLOW_PIPELINE: import("./pipeline").Pipeline<{
     }, input: {
         request?: import("../../../r-bridge/retriever").RParseRequests;
         parser?: Parser<import("../../../r-bridge/parser").KnownParserType>;
-    }, config: FlowrConfigOptions) => import("../../../dataflow/info").DataflowInformation;
+    }, config: FlowrConfigOptions) => import("../../../dataflow/info").DataflowInformation & {
+        cfgQuick: import("../../../control-flow/control-flow-graph").ControlFlowInformation | undefined;
+    };
     readonly requiredInput: {};
     readonly name: "dataflow";
     readonly description: "Construct the dataflow graph";
@@ -534,7 +548,9 @@ export declare const TREE_SITTER_DATAFLOW_PIPELINE: import("./pipeline").Pipelin
     }, input: {
         request?: import("../../../r-bridge/retriever").RParseRequests;
         parser?: Parser<import("../../../r-bridge/parser").KnownParserType>;
-    }, config: FlowrConfigOptions) => import("../../../dataflow/info").DataflowInformation;
+    }, config: FlowrConfigOptions) => import("../../../dataflow/info").DataflowInformation & {
+        cfgQuick: import("../../../control-flow/control-flow-graph").ControlFlowInformation | undefined;
+    };
     readonly requiredInput: {};
     readonly name: "dataflow";
     readonly description: "Construct the dataflow graph";

package/dataflow/environments/default-builtin-config.js

@@ -212,6 +212,14 @@ exports.DefaultBuiltinConfig = [
     { type: 'function', names: ['('], processor: 'builtin:default', config: { returnsNthArgument: 0 }, assumePrimitive: true },
     { type: 'function', names: ['load', 'load_all', 'setwd', 'set.seed'], processor: 'builtin:default', config: { hasUnknownSideEffects: true, forceArgs: [true] }, assumePrimitive: false },
     { type: 'function', names: ['body', 'formals', 'environment'], processor: 'builtin:default', config: { hasUnknownSideEffects: true, forceArgs: [true] }, assumePrimitive: true },
+    { type: 'function', names: ['.Call', '.External', '.C', '.Fortran'], processor: 'builtin:default', config: { hasUnknownSideEffects: true, forceArgs: [true],
+            treatAsFnCall: {
+                '.Call': ['.NAME'],
+                '.External': ['.NAME'],
+                '.C': ['.NAME'],
+                '.Fortran': ['.NAME']
+            }
+        }, assumePrimitive: true },
     { type: 'function', names: ['eval'], processor: 'builtin:eval', config: { includeFunctionCall: true }, assumePrimitive: true },
     { type: 'function', names: ['cat'], processor: 'builtin:default', config: { forceArgs: 'all', hasUnknownSideEffects: { type: 'link-to-last-call', callName: /^sink$/ } }, assumePrimitive: false },
     { type: 'function', names: ['switch'], processor: 'builtin:default', config: { forceArgs: [true] }, assumePrimitive: false },

package/dataflow/eval/resolve/alias-tracking.js

@@ -138,6 +138,8 @@ function resolveIdToValue(id, { environment, graph, idMap, full = true, resolve
             else {
                 return r_value_1.Top;
             }
+        case type_1.RType.FunctionDefinition:
+            return (0, set_constants_1.setFrom)({ type: 'function-definition' });
         case type_1.RType.FunctionCall:
         case type_1.RType.BinaryOp:
         case type_1.RType.UnaryOp:

package/dataflow/eval/resolve/resolve.js

@@ -41,6 +41,9 @@ function resolveNode(resolve, a, env, graph, map) {
     else if (a.type === type_1.RType.Logical) {
         return a.content.valueOf() ? logical_constants_1.ValueLogicalTrue : logical_constants_1.ValueLogicalFalse;
     }
+    else if (a.type === type_1.RType.FunctionDefinition) {
+        return { type: 'function-definition' };
+    }
     else if ((a.type === type_1.RType.FunctionCall || a.type === type_1.RType.BinaryOp || a.type === type_1.RType.UnaryOp) && graph) {
         const origin = (0, dfg_get_origin_1.getOriginInDfg)(graph, a.info.id)?.[0];
         if (origin === undefined || origin.type !== 3 /* OriginType.BuiltInFunctionOrigin */) {

package/dataflow/eval/values/r-value.d.ts

@@ -37,6 +37,9 @@ export interface ValueString<Str extends Lift<RStringValue> = Lift<RStringValue>
     type: 'string';
     value: Str;
 }
+export interface ValueFunctionDefinition {
+    type: 'function-definition';
+}
 export interface ValueMissing {
     type: 'missing';
 }
@@ -45,7 +48,7 @@ export interface ValueLogical {
     type: 'logical';
     value: Lift<TernaryLogical>;
 }
-export type Value = Lift<ValueInterval | ValueVector | ValueSet | ValueNumber | ValueString | ValueLogical | ValueMissing>;
+export type Value = Lift<ValueInterval | ValueVector | ValueSet | ValueNumber | ValueString | ValueLogical | ValueMissing | ValueFunctionDefinition>;
 export type ValueType<V> = V extends {
     type: infer T;
 } ? T : never;

package/dataflow/eval/values/r-value.js

@@ -82,6 +82,8 @@ function stringifyValue(value) {
                 return tryStringifyBoTop(v.value, l => l === 'maybe' ? 'maybe' : l ? 'TRUE' : 'FALSE', () => '⊤ (logical)', () => '⊥ (logical)');
             case 'missing':
                 return '(missing)';
+            case 'function-definition':
+                return 'fn-def';
             default:
                 (0, assert_1.assertUnreachable)(t);
         }

package/dataflow/extractor.d.ts

@@ -3,6 +3,7 @@ import type { DataflowProcessors } from './processor';
 import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RParseRequests } from '../r-bridge/retriever';
 import type { KnownParserType, Parser } from '../r-bridge/parser';
+import type { ControlFlowInformation } from '../control-flow/control-flow-graph';
 import type { FlowrConfigOptions } from '../config';
 /**
  * The best friend of {@link produceDataFlowGraph} and {@link processDataflowFor}.
@@ -15,4 +16,6 @@ export declare const processors: DataflowProcessors<ParentInformation>;
  * (e.g., in the event of a `source` call).
  * For the actual, canonical fold entry point, see {@link processDataflowFor}.
  */
-export declare function produceDataFlowGraph<OtherInfo>(parser: Parser<KnownParserType>, request: RParseRequests, completeAst: NormalizedAst<OtherInfo & ParentInformation>, config: FlowrConfigOptions): DataflowInformation;
+export declare function produceDataFlowGraph<OtherInfo>(parser: Parser<KnownParserType>, request: RParseRequests, completeAst: NormalizedAst<OtherInfo & ParentInformation>, config: FlowrConfigOptions): DataflowInformation & {
+    cfgQuick: ControlFlowInformation | undefined;
+};

package/dataflow/extractor.js

@@ -59,14 +59,14 @@ exports.processors = {
     }
 };
 function resolveLinkToSideEffects(ast, graph) {
-    let cfg = undefined;
+    let cf = undefined;
     for (const s of graph.unknownSideEffects) {
         if (typeof s !== 'object') {
             continue;
         }
-        cfg ??= (0, extract_cfg_1.extractCfgQuick)(ast).graph;
+        cf ??= (0, extract_cfg_1.extractCfgQuick)(ast);
         /* this has to change whenever we add a new link to relations because we currently offer no abstraction for the type */
-        const potentials = (0, identify_link_to_last_call_relation_1.identifyLinkToLastCallRelation)(s.id, cfg, graph, s.linkTo);
+        const potentials = (0, identify_link_to_last_call_relation_1.identifyLinkToLastCallRelation)(s.id, cf?.graph, graph, s.linkTo);
         for (const pot of potentials) {
             graph.addEdge(s.id, pot, edge_1.EdgeType.Reads);
         }
@@ -74,6 +74,7 @@ function resolveLinkToSideEffects(ast, graph) {
             graph.unknownSideEffects.delete(s);
         }
     }
+    return cf;
 }
 /**
  * This is the main function to produce the dataflow graph from a given request and normalized AST.
@@ -114,7 +115,8 @@ function produceDataFlowGraph(parser, request, completeAst, config) {
     }
     // finally, resolve linkages
     (0, built_in_function_definition_1.updateNestedFunctionCalls)(df.graph, df.environment);
-    resolveLinkToSideEffects(completeAst, df.graph);
-    return df;
+    const cfgQuick = resolveLinkToSideEffects(completeAst, df.graph);
+    // performance optimization: return cfgQuick as part of the result to avoid recomputation
+    return { ...df, cfgQuick };
 }
 //# sourceMappingURL=extractor.js.map

package/dataflow/fn/higher-order-function.d.ts

@@ -0,0 +1,9 @@
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { DataflowGraph } from '../graph/graph';
+/**
+ * Determines whether the function with the given id is a higher-order function, i.e.,
+ * either takes a function as an argument or (may) returns a function.
+ * If the return is an identity, e.g., `function(x) x`, this is not considered higher-order,
+ * if no function is passed as an argument.
+ */
+export declare function isHigherOrder(id: NodeId, graph: DataflowGraph): boolean;