@eagleoutice/flowr 2.2.0 → 2.2.2

package/queries/query.d.ts

@@ -16,7 +16,9 @@ import Joi from 'joi';
 import type { LocationMapQuery } from './catalog/location-map-query/location-map-query-format';
 import type { ConfigQuery } from './catalog/config-query/config-query-format';
 import type { SearchQuery } from './catalog/search-query/search-query-format';
-export type Query = CallContextQuery | ConfigQuery | SearchQuery | DataflowQuery | NormalizedAstQuery | IdMapQuery | DataflowClusterQuery | StaticSliceQuery | LineageQuery | DependenciesQuery | LocationMapQuery;
+import type { HappensBeforeQuery } from './catalog/happens-before-query/happens-before-query-format';
+import type { ResolveValueQuery } from './catalog/resolve-value-query/resolve-value-query-format';
+export type Query = CallContextQuery | ConfigQuery | SearchQuery | DataflowQuery | NormalizedAstQuery | IdMapQuery | DataflowClusterQuery | StaticSliceQuery | LineageQuery | DependenciesQuery | LocationMapQuery | HappensBeforeQuery | ResolveValueQuery;
 export type QueryArgumentsWithType<QueryType extends BaseQueryFormat['type']> = Query & {
     type: QueryType;
 };
@@ -509,6 +511,122 @@ export declare const SupportedQueries: {
         }>>, queryResults: BaseQueryResult, result: string[]) => true;
         readonly schema: Joi.ObjectSchema<any>;
     };
+    readonly 'happens-before': {
+        readonly executor: typeof import("./catalog/happens-before-query/happens-before-query-executor").executeHappensBefore;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _processed: PipelineOutput<import("../core/steps/pipeline/pipeline").Pipeline<{
+            readonly name: "parse";
+            readonly humanReadableName: "parse with R shell";
+            readonly description: "Parse the given R code into an AST";
+            readonly processor: (_results: unknown, input: Partial<import("../r-bridge/parser").ParseRequiredInput<string>>) => Promise<import("../r-bridge/parser").ParseStepOutput<string>>;
+            readonly executed: import("../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+            readonly printer: {
+                readonly 0: typeof import("../core/print/print").internalPrinter;
+                readonly 2: {
+                    (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+                    (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+                };
+                readonly 5: ({ parsed }: import("../r-bridge/parser").ParseStepOutput<string>, config: import("../util/quads").QuadSerializationConfiguration) => string;
+            };
+            readonly dependencies: readonly [];
+            readonly requiredInput: import("../r-bridge/parser").ParseRequiredInput<string>;
+        } | {
+            readonly name: "normalize";
+            readonly humanReadableName: "normalize";
+            readonly description: "Normalize the AST to flowR's AST";
+            readonly processor: (results: {
+                parse?: import("../r-bridge/parser").ParseStepOutput<string>;
+            }, input: Partial<import("../core/steps/all/core/10-normalize").NormalizeRequiredInput>) => import("../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../r-bridge/lang-4.x/ast/model/model").RNode<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
+            readonly executed: import("../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+            readonly printer: {
+                readonly 0: typeof import("../core/print/print").internalPrinter;
+                readonly 2: typeof import("../core/print/normalize-printer").normalizedAstToJson;
+                readonly 5: typeof import("../core/print/normalize-printer").normalizedAstToQuads;
+                readonly 3: typeof import("../core/print/normalize-printer").printNormalizedAstToMermaid;
+                readonly 4: typeof import("../core/print/normalize-printer").printNormalizedAstToMermaidUrl;
+            };
+            readonly dependencies: readonly ["parse"];
+            readonly requiredInput: import("../core/steps/all/core/10-normalize").NormalizeRequiredInput;
+        } | {
+            readonly humanReadableName: "dataflow";
+            readonly processor: (results: {
+                normalize?: import("../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+            }, input: {
+                request?: import("../r-bridge/retriever").RParseRequests;
+                parser?: import("../r-bridge/parser").Parser<import("../r-bridge/parser").KnownParserType>;
+            }) => import("../dataflow/info").DataflowInformation;
+            readonly requiredInput: {};
+            readonly name: "dataflow";
+            readonly description: "Construct the dataflow graph";
+            readonly executed: import("../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+            readonly printer: {
+                readonly 0: typeof import("../core/print/print").internalPrinter;
+                readonly 2: typeof import("../core/print/dataflow-printer").dataflowGraphToJson;
+                readonly 5: typeof import("../core/print/dataflow-printer").dataflowGraphToQuads;
+                readonly 3: typeof import("../core/print/dataflow-printer").dataflowGraphToMermaid;
+                readonly 4: typeof import("../core/print/dataflow-printer").dataflowGraphToMermaidUrl;
+            };
+            readonly dependencies: readonly ["normalize"];
+        }>>, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly schema: Joi.ObjectSchema<any>;
+    };
+    readonly 'resolve-value': {
+        readonly executor: typeof import("./catalog/resolve-value-query/resolve-value-query-executor").executeResolveValueQuery;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _processed: PipelineOutput<import("../core/steps/pipeline/pipeline").Pipeline<{
+            readonly name: "parse";
+            readonly humanReadableName: "parse with R shell";
+            readonly description: "Parse the given R code into an AST";
+            readonly processor: (_results: unknown, input: Partial<import("../r-bridge/parser").ParseRequiredInput<string>>) => Promise<import("../r-bridge/parser").ParseStepOutput<string>>;
+            readonly executed: import("../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+            readonly printer: {
+                readonly 0: typeof import("../core/print/print").internalPrinter;
+                readonly 2: {
+                    (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+                    (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+                };
+                readonly 5: ({ parsed }: import("../r-bridge/parser").ParseStepOutput<string>, config: import("../util/quads").QuadSerializationConfiguration) => string;
+            };
+            readonly dependencies: readonly [];
+            readonly requiredInput: import("../r-bridge/parser").ParseRequiredInput<string>;
+        } | {
+            readonly name: "normalize";
+            readonly humanReadableName: "normalize";
+            readonly description: "Normalize the AST to flowR's AST";
+            readonly processor: (results: {
+                parse?: import("../r-bridge/parser").ParseStepOutput<string>;
+            }, input: Partial<import("../core/steps/all/core/10-normalize").NormalizeRequiredInput>) => import("../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../r-bridge/lang-4.x/ast/model/model").RNode<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
+            readonly executed: import("../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+            readonly printer: {
+                readonly 0: typeof import("../core/print/print").internalPrinter;
+                readonly 2: typeof import("../core/print/normalize-printer").normalizedAstToJson;
+                readonly 5: typeof import("../core/print/normalize-printer").normalizedAstToQuads;
+                readonly 3: typeof import("../core/print/normalize-printer").printNormalizedAstToMermaid;
+                readonly 4: typeof import("../core/print/normalize-printer").printNormalizedAstToMermaidUrl;
+            };
+            readonly dependencies: readonly ["parse"];
+            readonly requiredInput: import("../core/steps/all/core/10-normalize").NormalizeRequiredInput;
+        } | {
+            readonly humanReadableName: "dataflow";
+            readonly processor: (results: {
+                normalize?: import("../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+            }, input: {
+                request?: import("../r-bridge/retriever").RParseRequests;
+                parser?: import("../r-bridge/parser").Parser<import("../r-bridge/parser").KnownParserType>;
+            }) => import("../dataflow/info").DataflowInformation;
+            readonly requiredInput: {};
+            readonly name: "dataflow";
+            readonly description: "Construct the dataflow graph";
+            readonly executed: import("../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+            readonly printer: {
+                readonly 0: typeof import("../core/print/print").internalPrinter;
+                readonly 2: typeof import("../core/print/dataflow-printer").dataflowGraphToJson;
+                readonly 5: typeof import("../core/print/dataflow-printer").dataflowGraphToQuads;
+                readonly 3: typeof import("../core/print/dataflow-printer").dataflowGraphToMermaid;
+                readonly 4: typeof import("../core/print/dataflow-printer").dataflowGraphToMermaidUrl;
+            };
+            readonly dependencies: readonly ["normalize"];
+        }>>, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly schema: Joi.ObjectSchema<any>;
+    };
 };
 export type SupportedQueryTypes = keyof typeof SupportedQueries;
 export type QueryResult<Type extends Query['type']> = ReturnType<typeof SupportedQueries[Type]['executor']>;

package/queries/query.js

@@ -24,6 +24,8 @@ const joi_1 = __importDefault(require("joi"));
 const location_map_query_format_1 = require("./catalog/location-map-query/location-map-query-format");
 const config_query_format_1 = require("./catalog/config-query/config-query-format");
 const search_query_format_1 = require("./catalog/search-query/search-query-format");
+const happens_before_query_format_1 = require("./catalog/happens-before-query/happens-before-query-format");
+const resolve_value_query_format_1 = require("./catalog/resolve-value-query/resolve-value-query-format");
 exports.SupportedQueries = {
     'call-context': call_context_query_format_1.CallContextQueryDefinition,
     'config': config_query_format_1.ConfigQueryDefinition,
@@ -35,7 +37,9 @@ exports.SupportedQueries = {
     'lineage': lineage_query_format_1.LineageQueryDefinition,
     'dependencies': dependencies_query_format_1.DependenciesQueryDefinition,
     'location-map': location_map_query_format_1.LocationMapQueryDefinition,
-    'search': search_query_format_1.SearchQueryDefinition
+    'search': search_query_format_1.SearchQueryDefinition,
+    'happens-before': happens_before_query_format_1.HappensBeforeQueryDefinition,
+    'resolve-value': resolve_value_query_format_1.ResolveValueQueryDefinition
 };
 function executeQueriesOfSameType(data, ...queries) {
     (0, assert_1.guard)(queries.length > 0, 'At least one query must be provided');

package/r-bridge/data/data.d.ts

@@ -190,8 +190,8 @@ export declare const flowrCapabilities: {
                     readonly supported: "fully";
                     readonly description: "_Detect calls like `x[]`, `x[2,,42]`, ..._";
                 }, {
-                    readonly name: "Subsetting";
-                    readonly id: "subsetting";
+                    readonly name: "Subsetting (Multiple Indices)";
+                    readonly id: "subsetting-multiple";
                     readonly supported: "fully";
                     readonly description: "_Detect calls like `x[i > 3]`, `x[c(1,3)]`, ..._";
                 }];

package/r-bridge/data/data.js

@@ -237,8 +237,8 @@ exports.flowrCapabilities = {
                                     description: '_Detect calls like `x[]`, `x[2,,42]`, ..._'
                                 },
                                 {
-                                    name: 'Subsetting',
-                                    id: 'subsetting',
+                                    name: 'Subsetting (Multiple Indices)',
+                                    id: 'subsetting-multiple',
                                     supported: 'fully',
                                     description: '_Detect calls like `x[i > 3]`, `x[c(1,3)]`, ..._'
                                 }

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

@@ -17,6 +17,9 @@ function normalizeTreeSitterTreeToAst(tree) {
     }
     return root;
 }
+function nonErrorChildren(node) {
+    return node.children.filter(n => n.type !== tree_sitter_types_1.TreeSitterType.Error);
+}
 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 +33,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 +48,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 +81,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 +154,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 +165,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 +180,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 +192,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 +238,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 +249,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 +259,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 +267,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 +309,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 +360,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 +375,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 +402,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 +435,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 +448,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 +466,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 +477,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/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",
@@ -25,6 +26,8 @@ interface CfgFlowDependencyEdge extends MergeableRecord {
 }
 interface CfgControlDependencyEdge extends MergeableRecord {
     label: 'CD';
+    /** the id which caused the control dependency */
+    caused: NodeId;
     when: typeof RTrue | typeof RFalse;
 }
 export type CfgEdge = CfgFlowDependencyEdge | CfgControlDependencyEdge;
@@ -55,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) => {
@@ -134,10 +153,10 @@ function cfgIfThenElse(ifNode, condition, then, otherwise) {
     }
     for (const exitPoint of condition.exitPoints) {
         for (const entryPoint of then.entryPoints) {
-            graph.addEdge(entryPoint, exitPoint, { label: 'CD', when: convert_values_1.RTrue });
+            graph.addEdge(entryPoint, exitPoint, { label: 'CD', when: convert_values_1.RTrue, caused: ifNode.info.id });
         }
         for (const entryPoint of otherwise?.entryPoints ?? []) {
-            graph.addEdge(entryPoint, exitPoint, { label: 'CD', when: convert_values_1.RFalse });
+            graph.addEdge(entryPoint, exitPoint, { label: 'CD', when: convert_values_1.RFalse, caused: ifNode.info.id });
         }
     }
     for (const entryPoint of condition.entryPoints) {
@@ -148,7 +167,7 @@ function cfgIfThenElse(ifNode, condition, then, otherwise) {
     }
     if (!otherwise) {
         for (const exitPoint of condition.exitPoints) {
-            graph.addEdge(ifNode.info.id + '-exit', exitPoint, { label: 'CD', when: convert_values_1.RFalse });
+            graph.addEdge(ifNode.info.id + '-exit', exitPoint, { label: 'CD', when: convert_values_1.RFalse, caused: ifNode.info.id });
         }
     }
     return {
@@ -165,7 +184,7 @@ function cfgRepeat(repeat, body) {
     graph.addVertex({ id: repeat.info.id, name: repeat.type, type: identifyMayStatementType(repeat) });
     graph.addVertex({ id: repeat.info.id + '-exit', name: 'repeat-exit', type: "end-marker" /* CfgVertexType.EndMarker */ });
     for (const entryPoint of body.entryPoints) {
-        graph.addEdge(repeat.info.id, entryPoint, { label: 'FD' });
+        graph.addEdge(entryPoint, repeat.info.id, { label: 'FD' });
     }
     // loops automatically
     for (const next of [...body.nexts, ...body.exitPoints]) {
@@ -186,7 +205,7 @@ function cfgWhile(whileLoop, condition, body) {
     }
     for (const exit of condition.exitPoints) {
         for (const entry of body.entryPoints) {
-            graph.addEdge(entry, exit, { label: 'CD', when: convert_values_1.RTrue });
+            graph.addEdge(entry, exit, { label: 'CD', when: convert_values_1.RTrue, caused: whileLoop.info.id });
         }
     }
     for (const entryPoint of body.entryPoints) {
@@ -200,7 +219,7 @@ function cfgWhile(whileLoop, condition, body) {
     }
     // while can break on the condition as well
     for (const exit of condition.exitPoints) {
-        graph.addEdge(whileLoop.info.id + '-exit', exit, { label: 'CD', when: convert_values_1.RFalse });
+        graph.addEdge(whileLoop.info.id + '-exit', exit, { label: 'CD', when: convert_values_1.RFalse, caused: whileLoop.info.id });
     }
     return { graph, breaks: [], nexts: [], returns: body.returns, exitPoints: [whileLoop.info.id + '-exit'], entryPoints: [whileLoop.info.id] };
 }
@@ -220,7 +239,7 @@ function cfgFor(forLoop, variable, vector, body) {
     }
     for (const exit of variable.exitPoints) {
         for (const entry of body.entryPoints) {
-            graph.addEdge(entry, exit, { label: 'CD', when: convert_values_1.RTrue });
+            graph.addEdge(entry, exit, { label: 'CD', when: convert_values_1.RTrue, caused: forLoop.info.id });
         }
     }
     for (const next of [...body.nexts, ...body.exitPoints]) {
@@ -231,7 +250,7 @@ function cfgFor(forLoop, variable, vector, body) {
     }
     // while can break on the condition as well
     for (const exit of variable.exitPoints) {
-        graph.addEdge(forLoop.info.id + '-exit', exit, { label: 'CD', when: convert_values_1.RFalse });
+        graph.addEdge(forLoop.info.id + '-exit', exit, { label: 'CD', when: convert_values_1.RFalse, caused: forLoop.info.id });
     }
     return { graph, breaks: [], nexts: [], returns: body.returns, exitPoints: [forLoop.info.id + '-exit'], entryPoints: [forLoop.info.id] };
 }
@@ -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/cfg/happens-before.d.ts

@@ -0,0 +1,7 @@
+import type { ControlFlowGraph } from './cfg';
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { Ternary } from '../logic';
+/**
+ * Determines if node `a` happens before node `b` in the control flow graph.
+ */
+export declare function happensBefore(cfg: ControlFlowGraph, a: NodeId, b: NodeId): Ternary;