@eagleoutice/flowr 2.2.1 → 2.2.3

package/r-bridge/lang-4.x/ast/parser/json/format.js

@@ -7,6 +7,9 @@ const retriever_1 = require("../../../../retriever");
 const assert_1 = require("../../../../../util/assert");
 const type_1 = require("../../model/type");
 exports.RootId = 0;
+/**
+ * Takes the raw {@link RShell} output and extracts the csv information contained
+ */
 function prepareParsedData(data) {
     let json;
     try {
@@ -36,6 +39,9 @@ function prepareParsedData(data) {
     }
     return roots;
 }
+/**
+ * Takes the CSV-Entries and maps them to the old json format for compatibility.
+ */
 function convertPreparedParsedData(roots) {
     const partialEntry = {
         token: type_1.RawRType.ExpressionList,

package/r-bridge/lang-4.x/ast/parser/json/parser.d.ts

@@ -1,10 +1,21 @@
 import type { IdGenerator, NormalizedAst } from '../../model/processing/decorate';
-import type { NoInfo } from '../../model/model';
+import type { NoInfo, RNode } from '../../model/model';
 import type { ParseStepOutputTS } from '../../../../../core/steps/all/core/01-parse-tree-sitter';
 import type { ParseStepOutput } from '../../../../parser';
 export declare const parseLog: import("tslog").Logger<import("tslog").ILogObj>;
 /**
  * Take the output as produced by the parse step and normalize the AST from the R parser.
+ *
+ * @see {@link normalizeButNotDecorated} for a version that does not decorate the AST
+ * @see {@link normalizeTreeSitter} for a version that normalizes the AST from the TreeSitter parser
+ */
+export declare function normalize(parsed: ParseStepOutput<string>, getId?: IdGenerator<NoInfo>, file?: string): NormalizedAst;
+/**
+ * Take the output as produced by the parse step and normalize the AST from the R parser.
+ * For additional decoration with ${@link decorateAst} use {@link normalize}.
+ */
+export declare function normalizeButNotDecorated({ parsed }: ParseStepOutput<string>): RNode;
+/**
+ * Tree-Sitter pendant to {@link normalize}.
  */
-export declare function normalize({ parsed }: ParseStepOutput<string>, getId?: IdGenerator<NoInfo>, file?: string): NormalizedAst;
 export declare function normalizeTreeSitter({ parsed }: ParseStepOutputTS, getId?: IdGenerator<NoInfo>, file?: string): NormalizedAst;

package/r-bridge/lang-4.x/ast/parser/json/parser.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseLog = void 0;
 exports.normalize = normalize;
+exports.normalizeButNotDecorated = normalizeButNotDecorated;
 exports.normalizeTreeSitter = normalizeTreeSitter;
 const format_1 = require("./format");
 const log_1 = require("../../../../../util/log");
@@ -11,13 +12,28 @@ const tree_sitter_normalize_1 = require("../../../tree-sitter/tree-sitter-normal
 exports.parseLog = log_1.log.getSubLogger({ name: 'ast-parser' });
 /**
  * Take the output as produced by the parse step and normalize the AST from the R parser.
+ *
+ * @see {@link normalizeButNotDecorated} for a version that does not decorate the AST
+ * @see {@link normalizeTreeSitter} for a version that normalizes the AST from the TreeSitter parser
  */
-function normalize({ parsed }, getId = (0, decorate_1.deterministicCountingIdGenerator)(0), file) {
+function normalize(parsed, getId = (0, decorate_1.deterministicCountingIdGenerator)(0), file) {
+    return (0, decorate_1.decorateAst)(normalizeButNotDecorated(parsed), { getId, file });
+}
+/**
+ * Take the output as produced by the parse step and normalize the AST from the R parser.
+ * For additional decoration with ${@link decorateAst} use {@link normalize}.
+ */
+function normalizeButNotDecorated({ parsed }) {
     const data = { currentRange: undefined, currentLexeme: undefined };
     const object = (0, format_1.convertPreparedParsedData)((0, format_1.prepareParsedData)(parsed));
-    return (0, decorate_1.decorateAst)((0, normalize_root_1.normalizeRootObjToAst)(data, object), { getId, file });
+    return (0, normalize_root_1.normalizeRootObjToAst)(data, object);
 }
+/**
+ * Tree-Sitter pendant to {@link normalize}.
+ */
 function normalizeTreeSitter({ parsed }, getId = (0, decorate_1.deterministicCountingIdGenerator)(0), file) {
-    return (0, decorate_1.decorateAst)((0, tree_sitter_normalize_1.normalizeTreeSitterTreeToAst)(parsed), { getId, file });
+    const result = (0, decorate_1.decorateAst)((0, tree_sitter_normalize_1.normalizeTreeSitterTreeToAst)(parsed), { getId, file });
+    result.hasError = parsed.rootNode.hasError;
+    return result;
 }
 //# sourceMappingURL=parser.js.map

package/r-bridge/lang-4.x/ast/parser/main/internal/structure/normalize-root.d.ts

@@ -1,4 +1,7 @@
 import type { NormalizerData } from '../../normalizer-data';
 import type { RExpressionList } from '../../../../model/nodes/r-expression-list';
 import type { JsonEntry } from '../../../json/format';
+/**
+ * Takes the parse dta as object and produces an undecorated, normalized AST.
+ */
 export declare function normalizeRootObjToAst(data: NormalizerData, obj: JsonEntry): RExpressionList;

package/r-bridge/lang-4.x/ast/parser/main/internal/structure/normalize-root.js

@@ -6,6 +6,9 @@ const normalize_expressions_1 = require("./normalize-expressions");
 const log_1 = require("../../../../../../../util/log");
 const arrays_1 = require("../../../../../../../util/arrays");
 const type_1 = require("../../../../model/type");
+/**
+ * Takes the parse dta as object and produces an undecorated, normalized AST.
+ */
 function normalizeRootObjToAst(data, obj) {
     const exprContent = obj.token;
     (0, normalize_meta_1.assureTokenType)(exprContent, type_1.RawRType.ExpressionList);

package/r-bridge/lang-4.x/tree-sitter/tree-sitter-normalize.js

@@ -17,6 +17,14 @@ function normalizeTreeSitterTreeToAst(tree) {
     }
     return root;
 }
+function nonErrorChildren(node) {
+    if (node.hasError) {
+        return [];
+    }
+    else {
+        return node.children;
+    }
+}
 function convertTreeNode(node) {
     // generally, the grammar source file dictates what children a node has in what order:
     // https://github.com/r-lib/tree-sitter-r/blob/main/grammar.js
@@ -30,7 +38,7 @@ function convertTreeNode(node) {
     };
     switch (node.type) {
         case tree_sitter_types_1.TreeSitterType.Program: {
-            const [comments, children] = splitComments(node.children);
+            const [comments, children] = splitComments(nonErrorChildren(node));
             const body = children.map(n => [n, convertTreeNode(n)]);
             const remainingComments = linkCommentsToNextNodes(body, comments);
             return {
@@ -45,7 +53,7 @@ function convertTreeNode(node) {
         }
         case tree_sitter_types_1.TreeSitterType.BracedExpression:
         case tree_sitter_types_1.TreeSitterType.ParenthesizedExpression: {
-            const [comments, children] = splitComments(node.children);
+            const [comments, children] = splitComments(nonErrorChildren(node));
             const opening = children[0];
             const body = children.slice(1, -1).map(n => [n, convertTreeNode(n)]);
             const remainingComments = linkCommentsToNextNodes(body, comments);
@@ -78,9 +86,10 @@ function convertTreeNode(node) {
             };
         }
         case tree_sitter_types_1.TreeSitterType.BinaryOperator: {
-            const lhs = convertTreeNode(node.children[0]);
-            const rhs = convertTreeNode(node.children[node.children.length - 1]);
-            const [commentsBoth, [op]] = splitComments(node.children.slice(1, -1));
+            const children = nonErrorChildren(node);
+            const lhs = convertTreeNode(children[0]);
+            const rhs = convertTreeNode(children[children.length - 1]);
+            const [commentsBoth, [op]] = splitComments(children.slice(1, -1));
             const comments = commentsBoth.map(c => c[1]);
             const opSource = makeSourceRange(op);
             const lhsAsArg = {
@@ -150,7 +159,7 @@ function convertTreeNode(node) {
             }
         }
         case tree_sitter_types_1.TreeSitterType.UnaryOperator: {
-            const [op, operand] = node.children;
+            const [op, operand] = nonErrorChildren(node);
             return {
                 type: type_1.RType.UnaryOp,
                 operand: convertTreeNode(operand),
@@ -161,7 +170,7 @@ function convertTreeNode(node) {
             };
         }
         case tree_sitter_types_1.TreeSitterType.NamespaceOperator: {
-            const [lhs, /* :: or ::: */ , rhs] = node.children;
+            const [lhs, /* :: or ::: */ , rhs] = nonErrorChildren(node);
             return {
                 type: type_1.RType.Symbol,
                 location: makeSourceRange(rhs),
@@ -176,6 +185,7 @@ function convertTreeNode(node) {
         case tree_sitter_types_1.TreeSitterType.Na:
         case tree_sitter_types_1.TreeSitterType.Null:
         case tree_sitter_types_1.TreeSitterType.Dots:
+        case tree_sitter_types_1.TreeSitterType.DotDotI:
         case tree_sitter_types_1.TreeSitterType.Identifier:
         case tree_sitter_types_1.TreeSitterType.Return:
             return {
@@ -187,22 +197,24 @@ function convertTreeNode(node) {
                 ...defaultInfo
             };
         case tree_sitter_types_1.TreeSitterType.IfStatement: {
-            const [ifNode, /* ( */ , condition, /* ) */ , then, /* else */ , ...otherwise] = node.children;
+            const [ifNode, /* ( */ , condition, /* ) */ , then, /* else */ , ...otherwise] = nonErrorChildren(node);
+            const filteredOtherwise = otherwise.filter(n => n.type !== tree_sitter_types_1.TreeSitterType.ElseStatement);
             return {
                 type: type_1.RType.IfThenElse,
                 condition: convertTreeNode(condition),
                 then: (0, normalize_meta_1.ensureExpressionList)(convertTreeNode(then)),
-                otherwise: otherwise.length > 0 ? (0, normalize_meta_1.ensureExpressionList)(convertTreeNode(otherwise[0])) : undefined,
+                otherwise: filteredOtherwise.length > 0 ? (0, normalize_meta_1.ensureExpressionList)(convertTreeNode(filteredOtherwise[0])) : undefined,
                 location: makeSourceRange(ifNode),
                 lexeme: ifNode.text,
                 ...defaultInfo
             };
         }
         case tree_sitter_types_1.TreeSitterType.ForStatement: {
-            const forNode = node.children[0]; // we follow with a (
-            const variable = getNodesUntil(node.children, 'in', 2); // we follow with the "in"
-            const sequence = getNodesUntil(node.children, ')', 2 + variable.length + 1); // we follow with a (
-            const body = node.children[2 + variable.length + 1 + sequence.length + 1];
+            const children = nonErrorChildren(node);
+            const forNode = children[0]; // we follow with a (
+            const variable = getNodesUntil(children, 'in', 2); // we follow with the "in"
+            const sequence = getNodesUntil(children, ')', 2 + variable.length + 1); // we follow with a (
+            const body = children[2 + variable.length + 1 + sequence.length + 1];
             const [variableComments, [variableNode]] = splitComments(variable);
             const [sequenceComments, [sequenceNode]] = splitComments(sequence);
             return {
@@ -231,7 +243,7 @@ function convertTreeNode(node) {
             };
         }
         case tree_sitter_types_1.TreeSitterType.WhileStatement: {
-            const [whileNode, /* ( */ , condition, /* ) */ , body] = node.children;
+            const [whileNode, /* ( */ , condition, /* ) */ , body] = nonErrorChildren(node);
             return {
                 type: type_1.RType.WhileLoop,
                 condition: convertTreeNode(condition),
@@ -242,7 +254,7 @@ function convertTreeNode(node) {
             };
         }
         case tree_sitter_types_1.TreeSitterType.RepeatStatement: {
-            const [repeatNode, body] = node.children;
+            const [repeatNode, body] = nonErrorChildren(node);
             return {
                 type: type_1.RType.RepeatLoop,
                 body: (0, normalize_meta_1.ensureExpressionList)(convertTreeNode(body)),
@@ -252,7 +264,7 @@ function convertTreeNode(node) {
             };
         }
         case tree_sitter_types_1.TreeSitterType.Call: {
-            const [func, argsParentheses] = node.children;
+            const [func, argsParentheses] = nonErrorChildren(node);
             // tree-sitter wraps next and break in a function call, but we don't, so unwrap
             if (func.type === tree_sitter_types_1.TreeSitterType.Next || func.type == tree_sitter_types_1.TreeSitterType.Break) {
                 return {
@@ -260,7 +272,7 @@ function convertTreeNode(node) {
                     ...defaultInfo
                 };
             }
-            const args = (0, arrays_1.splitArrayOn)(argsParentheses.children.slice(1, -1), x => x.type === 'comma');
+            const args = (0, arrays_1.splitArrayOn)(nonErrorChildren(argsParentheses).slice(1, -1), x => x.type === 'comma');
             const funcRange = makeSourceRange(func);
             const call = {
                 arguments: args.map(n => n.length == 0 ? r_function_call_1.EmptyArgument : convertTreeNode(n[0])),
@@ -302,7 +314,7 @@ function convertTreeNode(node) {
             }
         }
         case tree_sitter_types_1.TreeSitterType.FunctionDefinition: {
-            const [name, paramsParens, body] = node.children;
+            const [name, paramsParens, body] = nonErrorChildren(node);
             const params = (0, arrays_1.splitArrayOn)(paramsParens.children.slice(1, -1), x => x.type === 'comma');
             return {
                 type: type_1.RType.FunctionDefinition,
@@ -353,9 +365,9 @@ function convertTreeNode(node) {
         case tree_sitter_types_1.TreeSitterType.Subset:
         case tree_sitter_types_1.TreeSitterType.Subset2: {
             // subset has children like a and [x]
-            const [func, content] = node.children;
+            const [func, content] = nonErrorChildren(node);
             // bracket is now [ or [[ and argsClosing is x] or x]]
-            const [bracket, ...argsClosing] = content.children;
+            const [bracket, ...argsClosing] = nonErrorChildren(content);
             const args = (0, arrays_1.splitArrayOn)(argsClosing.slice(0, -1), x => x.type === 'comma');
             return {
                 type: type_1.RType.Access,
@@ -368,7 +380,7 @@ function convertTreeNode(node) {
             };
         }
         case tree_sitter_types_1.TreeSitterType.ExtractOperator: {
-            const [lhs, operator, rhs] = node.children;
+            const [lhs, operator, rhs] = nonErrorChildren(node);
             const rhsRange = makeSourceRange(rhs);
             return {
                 type: type_1.RType.Access,
@@ -395,11 +407,12 @@ function convertTreeNode(node) {
             };
         }
         case tree_sitter_types_1.TreeSitterType.Parameter: {
-            const name = node.children[0];
+            const children = nonErrorChildren(node);
+            const name = children[0];
             const nameRange = makeSourceRange(name);
             let defaultValue = undefined;
-            if (node.children.length == 3) {
-                defaultValue = convertTreeNode(node.children[2]);
+            if (children.length == 3) {
+                defaultValue = convertTreeNode(children[2]);
             }
             return {
                 type: type_1.RType.Parameter,
@@ -427,8 +440,9 @@ function convertTreeNode(node) {
             };
         }
         case tree_sitter_types_1.TreeSitterType.Argument: {
-            if (node.children.length == 1) {
-                const [arg] = node.children;
+            const children = nonErrorChildren(node);
+            if (children.length == 1) {
+                const [arg] = children;
                 return {
                     type: type_1.RType.Argument,
                     name: undefined,
@@ -439,7 +453,7 @@ function convertTreeNode(node) {
                 };
             }
             else {
-                const [nameNode, /* = */ , valueNode] = node.children;
+                const [nameNode, /* = */ , valueNode] = children;
                 let name = convertTreeNode(nameNode);
                 // unescape argument names
                 if (name.type === type_1.RType.String) {
@@ -457,7 +471,7 @@ function convertTreeNode(node) {
                 return {
                     type: type_1.RType.Argument,
                     name: name,
-                    value: convertTreeNode(valueNode),
+                    value: valueNode ? convertTreeNode(valueNode) : undefined,
                     location: nameRange,
                     lexeme: nameNode.text,
                     info: {
@@ -468,8 +482,16 @@ function convertTreeNode(node) {
                 };
             }
         }
+        case tree_sitter_types_1.TreeSitterType.Comment:
+            return {
+                type: type_1.RType.Comment,
+                location: range,
+                content: node.text.slice(1),
+                lexeme: node.text,
+                ...defaultInfo
+            };
         default:
-            throw new normalizer_data_1.ParseError(`unexpected node type ${node.type}`);
+            throw new normalizer_data_1.ParseError(`unexpected node type ${node.type} at ${JSON.stringify(range)}`);
     }
 }
 function makeSourceRange(node) {

package/r-bridge/lang-4.x/tree-sitter/tree-sitter-types.d.ts

@@ -7,6 +7,7 @@ export declare enum TreeSitterType {
     NamespaceOperator = "namespace_operator",
     Identifier = "identifier",
     IfStatement = "if_statement",
+    ElseStatement = "else",
     ForStatement = "for_statement",
     WhileStatement = "while_statement",
     RepeatStatement = "repeat_statement",
@@ -31,5 +32,7 @@ export declare enum TreeSitterType {
     Parameter = "parameter",
     Argument = "argument",
     Dots = "dots",
-    Comment = "comment"
+    DotDotI = "dot_dot_i",
+    Comment = "comment",
+    Error = "ERROR"
 }

package/r-bridge/lang-4.x/tree-sitter/tree-sitter-types.js

@@ -11,6 +11,7 @@ var TreeSitterType;
     TreeSitterType["NamespaceOperator"] = "namespace_operator";
     TreeSitterType["Identifier"] = "identifier";
     TreeSitterType["IfStatement"] = "if_statement";
+    TreeSitterType["ElseStatement"] = "else";
     TreeSitterType["ForStatement"] = "for_statement";
     TreeSitterType["WhileStatement"] = "while_statement";
     TreeSitterType["RepeatStatement"] = "repeat_statement";
@@ -35,6 +36,8 @@ var TreeSitterType;
     TreeSitterType["Parameter"] = "parameter";
     TreeSitterType["Argument"] = "argument";
     TreeSitterType["Dots"] = "dots";
+    TreeSitterType["DotDotI"] = "dot_dot_i";
     TreeSitterType["Comment"] = "comment";
+    TreeSitterType["Error"] = "ERROR";
 })(TreeSitterType || (exports.TreeSitterType = TreeSitterType = {}));
 //# sourceMappingURL=tree-sitter-types.js.map

package/r-bridge/parser.d.ts

@@ -27,6 +27,16 @@ export interface ParseRequiredInput<T> {
 export interface ParseStepOutput<T> {
     /** The parsed AST of the R code as given by the R parse side */
     readonly parsed: T;
+    /** Additional meta information about the parse */
+    readonly '.parse-meta'?: {
+        /** The number of tokens in the AST */
+        readonly tokenCount: number;
+    };
 }
+/**
+ * Takes an input program and parses it using the given parser.
+ * @param _results - just a proxy for the pipeline, signifies that this function does not need prior knowledge of the pipeline
+ * @param input    - the input to the parse step
+ */
 export declare function parseRequests<T extends KnownParserType>(_results: unknown, input: Partial<ParseRequiredInput<T>>): Promise<ParseStepOutput<T>>;
 export {};

package/r-bridge/parser.js

@@ -1,14 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseRequests = parseRequests;
+function countChildren(node) {
+    let ret = 1;
+    for (const child of node.children) {
+        ret += countChildren(child);
+    }
+    return ret;
+}
+/**
+ * Takes an input program and parses it using the given parser.
+ * @param _results - just a proxy for the pipeline, signifies that this function does not need prior knowledge of the pipeline
+ * @param input    - the input to the parse step
+ */
 async function parseRequests(_results, input) {
     /* in the future, we want to expose all cases */
     const request = (Array.isArray(input.request) ? input.request[0] : input.request);
     if (input.parser?.async) {
-        return { parsed: await input.parser.parse(request) };
+        const parsed = await input.parser.parse(request);
+        return {
+            parsed,
+            '.parse-meta': typeof parsed === 'object' && 'rootNode' in parsed ? {
+                tokenCount: countChildren(parsed.rootNode),
+            } : undefined
+        };
     }
     else {
-        return { parsed: input.parser.parse(request) };
+        const parsed = input.parser.parse(request);
+        return {
+            parsed,
+            '.parse-meta': typeof parsed === 'object' && 'rootNode' in parsed ? {
+                tokenCount: countChildren(parsed.rootNode),
+            } : undefined
+        };
     }
 }
 //# sourceMappingURL=parser.js.map

package/search/flowr-search-builder.d.ts

@@ -111,7 +111,6 @@ export declare const Q: {
     readonly id: (id: NodeId) => FlowrSearchBuilder<"get">;
 };
 export type FlowrSearchBuilderType<Generator extends GeneratorNames = GeneratorNames, Transformers extends TransformerNames[] = TransformerNames[], Info = ParentInformation, ElementType = FlowrSearchElements<Info, FlowrSearchElement<Info>[]>> = FlowrSearchBuilder<Generator, Transformers, Info, ElementType>;
-type GetElements<F> = F extends FlowrSearchElements<infer Info, infer Elements> ? Elements extends FlowrSearchElement<Info>[] ? Elements : never : never;
 /**
  * The search query is a combination of a generator and a list of transformers
  * and allows this view to pass such queries in a serialized form.
@@ -172,7 +171,7 @@ export declare class FlowrSearchBuilder<Generator extends GeneratorNames, Transf
     /**
      * merge combines the search results with those of another search.
      */
-    merge<Generator2 extends GeneratorNames, Transformers2 extends TransformerNames[], OtherElementType extends FlowrSearchElements<Info, FlowrSearchElement<Info>[]>>(other: FlowrSearchBuilder<Generator2, Transformers2, Info, OtherElementType>): FlowrSearchBuilder<Generator, Transformers, Info, FlowrSearchElements<Info, [...GetElements<ElementType>, ...GetElements<OtherElementType>]>>;
+    merge<Generator2 extends GeneratorNames, Transformers2 extends TransformerNames[], OtherElementType extends FlowrSearchElements<Info, FlowrSearchElement<Info>[]>>(other: FlowrSearchBuilder<Generator2, Transformers2, Info, OtherElementType>): FlowrSearchBuilder<Generator, Transformers, Info>;
     /**
      * Construct the final search (this may happen automatically with most search handlers).
      *

package/search/flowr-search-builder.js

@@ -161,9 +161,7 @@ class FlowrSearchBuilder {
     /**
      * merge combines the search results with those of another search.
      */
-    merge(other /* | FlowrSearch<Info, Generator2, Transformers2, OtherElementType> */
-    // @ts-expect-error -- this works when merging, there is no info disparity
-    ) {
+    merge(other /* | FlowrSearch<Info, Generator2, Transformers2, OtherElementType> */) {
         this.search.push({ type: 'transformer', name: 'merge', args: { generator: other.generator, search: other.search } });
         return this;
     }

package/util/cfg/cfg.d.ts

@@ -3,6 +3,7 @@ import type { QuadSerializationConfiguration } from '../quads';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { NormalizedAst, ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { RFalse, RTrue } from '../../r-bridge/lang-4.x/convert-values';
+import type { DataflowGraph } from '../../dataflow/graph/graph';
 export declare const enum CfgVertexType {
     /** Marks a break point in a construct (e.g., between the name and the value of an argument, or the formals and the body of a function)  */
     MidMarker = "mid-marker",
@@ -57,7 +58,15 @@ export interface ControlFlowInformation extends MergeableRecord {
     graph: ControlFlowGraph;
 }
 export declare function emptyControlFlowInformation(): ControlFlowInformation;
-export declare function extractCFG<Info = ParentInformation>(ast: NormalizedAst<Info>): ControlFlowInformation;
+/**
+ * Given a normalized AST this approximates the control flow graph of the program.
+ * This few is different from the computation of the dataflow graph and may differ,
+ * especially because it focuses on intra-procedural analysis.
+ *
+ * @param ast - the normalized AST
+ * @param graph - additional dataflow facts to consider by the control flow extraction
+ */
+export declare function extractCFG<Info = ParentInformation>(ast: NormalizedAst<Info>, graph?: DataflowGraph): ControlFlowInformation;
 /**
  * Returns true if the given CFG equals the other CFG. False otherwise.
  */

package/util/cfg/cfg.js

@@ -12,6 +12,8 @@ const json_1 = require("../json");
 const fold_1 = require("../../r-bridge/lang-4.x/ast/model/processing/fold");
 const convert_values_1 = require("../../r-bridge/lang-4.x/convert-values");
 const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const linker_1 = require("../../dataflow/internal/linker");
+const vertex_1 = require("../../dataflow/graph/vertex");
 /**
  * This class represents the control flow graph of an R program.
  * The control flow may be hierarchical when confronted with function definitions (see {@link CfgVertex} and {@link CFG#rootVertexIds|rootVertexIds()}).
@@ -101,8 +103,25 @@ const cfgFolds = {
         foldArgument: cfgArgumentOrParameter
     }
 };
-function extractCFG(ast) {
-    return (0, fold_1.foldAst)(ast.ast, cfgFolds);
+function dataflowCfgFolds(dataflowGraph) {
+    return {
+        ...cfgFolds,
+        functions: {
+            ...cfgFolds.functions,
+            foldFunctionCall: cfgFunctionCallWithDataflow(dataflowGraph)
+        }
+    };
+}
+/**
+ * Given a normalized AST this approximates the control flow graph of the program.
+ * This few is different from the computation of the dataflow graph and may differ,
+ * especially because it focuses on intra-procedural analysis.
+ *
+ * @param ast - the normalized AST
+ * @param graph - additional dataflow facts to consider by the control flow extraction
+ */
+function extractCFG(ast, graph) {
+    return (0, fold_1.foldAst)(ast.ast, graph ? dataflowCfgFolds(graph) : cfgFolds);
 }
 function cfgLeaf(type) {
     return (leaf) => {
@@ -253,6 +272,9 @@ function cfgFunctionDefinition(fn, params, body) {
             graph.addEdge(fn.info.id + '-params', exit, { label: 'FD' });
         }
     }
+    if (params.length === 0) {
+        graph.addEdge(fn.info.id + '-params', fn.info.id, { label: 'FD' });
+    }
     for (const entry of body.entryPoints) {
         graph.addEdge(entry, fn.info.id + '-params', { label: 'FD' });
     }
@@ -296,6 +318,38 @@ function cfgFunctionCall(call, name, args) {
     // should not contain any breaks, nexts, or returns, (except for the body if something like 'break()')
     return info;
 }
+function cfgFunctionCallWithDataflow(graph) {
+    return (call, name, args) => {
+        const baseCFG = cfgFunctionCall(call, name, args);
+        /* try to resolve the call and link the target definitions */
+        const targets = (0, linker_1.getAllFunctionCallTargets)(call.info.id, graph);
+        const exits = [];
+        for (const target of targets) {
+            // we have to filter out non func-call targets as the call targets contains names and call ids
+            if ((0, vertex_1.isFunctionDefinitionVertex)(graph.getVertex(target))) {
+                baseCFG.graph.addEdge(call.info.id, target, { label: 'FD' });
+                exits.push(target + '-exit');
+            }
+        }
+        if (exits.length > 0) {
+            baseCFG.graph.addVertex({
+                id: call.info.id + '-resolved-call-exit',
+                name: 'resolved-call-exit',
+                type: "end-marker" /* CfgVertexType.EndMarker */
+            });
+            for (const exit of [...baseCFG.exitPoints, ...exits]) {
+                baseCFG.graph.addEdge(call.info.id + '-resolved-call-exit', exit, { label: 'FD' });
+            }
+            return {
+                ...baseCFG,
+                exitPoints: [call.info.id + '-resolved-call-exit']
+            };
+        }
+        else {
+            return baseCFG;
+        }
+    };
+}
 function cfgArgumentOrParameter(node, name, value) {
     const graph = new ControlFlowGraph();
     const info = { graph, breaks: [], nexts: [], returns: [], exitPoints: [node.info.id + '-exit'], entryPoints: [node.info.id] };

package/util/mermaid/dfg.d.ts

@@ -18,6 +18,8 @@ interface MermaidGraph {
     /** in the form of from-\>to because I am lazy, see {@link encodeEdge} */
     presentEdges: Set<string>;
     rootGraph: DataflowGraph;
+    /** if given, the dataflow graph will only focus on the "important" parts */
+    simplified?: boolean;
 }
 /**
  * Prints a {@link SourceRange|range} as a human readable string.
@@ -33,6 +35,7 @@ interface MermaidGraphConfiguration {
     markStyle?: MermaidMarkStyle;
     rootGraph?: DataflowGraph;
     presentEdges?: Set<string>;
+    simplified?: boolean;
 }
 export declare function graphToMermaid(config: MermaidGraphConfiguration): {
     string: string;

package/util/mermaid/dfg.js

@@ -37,14 +37,24 @@ function subflowToMermaid(nodeId, exitPoints, subflow, mermaid, idPrefix = '') {
         return;
     }
     const subflowId = `${idPrefix}flow-${nodeId}`;
-    mermaid.nodeLines.push(`\nsubgraph "${subflowId}" [function ${nodeId}]`);
+    if (mermaid.simplified) {
+        // get parent
+        const idMap = mermaid.rootGraph.idMap;
+        const node = idMap?.get(nodeId);
+        const nodeLexeme = node?.info.fullLexeme ?? node?.lexeme ?? '??';
+        mermaid.nodeLines.push(`\nsubgraph "${subflowId}" ["${(0, mermaid_1.escapeMarkdown)(nodeLexeme ?? 'function')}"]`);
+    }
+    else {
+        mermaid.nodeLines.push(`\nsubgraph "${subflowId}" [function ${nodeId}]`);
+    }
     const subgraph = graphToMermaidGraph(subflow.graph, {
         graph: mermaid.rootGraph,
         rootGraph: mermaid.rootGraph,
         idPrefix,
         includeEnvironments: mermaid.includeEnvironments,
         mark: mermaid.mark,
-        prefix: null
+        prefix: null,
+        simplified: mermaid.simplified
     });
     mermaid.nodeLines.push(...subgraph.nodeLines);
     mermaid.edgeLines.push(...subgraph.edgeLines);
@@ -143,10 +153,16 @@ function vertexToMermaid(info, mermaid, id, idPrefix, mark) {
     }
     const node = mermaid.rootGraph.idMap?.get(info.id);
     const lexeme = node?.lexeme ?? (node?.type === type_1.RType.ExpressionList ? node?.grouping?.[0]?.lexeme : '') ?? '??';
-    const escapedName = (0, mermaid_1.escapeMarkdown)(node ? `[${node.type}] ${lexeme}` : '??');
-    const deps = info.controlDependencies ? ', :may:' + info.controlDependencies.map(c => c.id + (c.when ? '+' : '-')).join(',') : '';
-    const n = node?.info.fullRange ?? node?.location ?? (node?.type === type_1.RType.ExpressionList ? node?.grouping?.[0].location : undefined);
-    mermaid.nodeLines.push(`    ${idPrefix}${id}${open}"\`${escapedName}${escapedName.length > 10 ? '\n      ' : ' '}(${id}${deps})\n      *${formatRange(n)}*${fCall ? displayFunctionArgMapping(info.args) : ''}\`"${close}`);
+    if (mermaid.simplified) {
+        const escapedName = '**' + (0, mermaid_1.escapeMarkdown)(node ? `${lexeme}` : '??') + '**' + (node ? `\n*${node.type}*` : '');
+        mermaid.nodeLines.push(`    ${idPrefix}${id}${open}"\`${escapedName}\`"${close}`);
+    }
+    else {
+        const escapedName = (0, mermaid_1.escapeMarkdown)(node ? `[${node.type}] ${lexeme}` : '??');
+        const deps = info.controlDependencies ? ', :may:' + info.controlDependencies.map(c => c.id + (c.when ? '+' : '-')).join(',') : '';
+        const n = node?.info.fullRange ?? node?.location ?? (node?.type === type_1.RType.ExpressionList ? node?.grouping?.[0].location : undefined);
+        mermaid.nodeLines.push(`    ${idPrefix}${id}${open}"\`${escapedName}${escapedName.length > 10 ? '\n      ' : ' '}(${id}${deps})\n      *${formatRange(n)}*${fCall ? displayFunctionArgMapping(info.args) : ''}\`"${close}`);
+    }
     if (mark?.has(id)) {
         mermaid.nodeLines.push(`    style ${idPrefix}${id} ${mermaid.markStyle.vertex} `);
     }
@@ -176,8 +192,8 @@ function vertexToMermaid(info, mermaid, id, idPrefix, mark) {
     }
 }
 // make the passing of root ids more performant again
-function graphToMermaidGraph(rootIds, { graph, prefix = 'flowchart TD', idPrefix = '', includeEnvironments = true, mark, rootGraph, presentEdges = new Set(), markStyle = { vertex: 'stroke:teal,stroke-width:7px,stroke-opacity:.8;', edge: 'stroke:teal,stroke-width:4.2px,stroke-opacity:.8' } }) {
-    const mermaid = { nodeLines: prefix === null ? [] : [prefix], edgeLines: [], presentEdges, mark, rootGraph: rootGraph ?? graph, includeEnvironments, markStyle };
+function graphToMermaidGraph(rootIds, { simplified, graph, prefix = 'flowchart TD', idPrefix = '', includeEnvironments = !simplified, mark, rootGraph, presentEdges = new Set(), markStyle = { vertex: 'stroke:teal,stroke-width:7px,stroke-opacity:.8;', edge: 'stroke:teal,stroke-width:4.2px,stroke-opacity:.8' } }) {
+    const mermaid = { nodeLines: prefix === null ? [] : [prefix], edgeLines: [], presentEdges, mark, rootGraph: rootGraph ?? graph, includeEnvironments, markStyle, simplified };
     for (const [id, info] of graph.vertices(true)) {
         if (rootIds.has(id)) {
             vertexToMermaid(info, mermaid, id, idPrefix, mark);