@eagleoutice/flowr 2.2.1 → 2.2.2

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",
@@ -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/range.d.ts

@@ -1,9 +1,27 @@
+/**
+ * A source position in a file.
+ *
+ * Please note that some packages like `xmlparsedata` use their own start and end only to break ties
+ * (e.g., `xmlparsedata` calculates them on a max col width approximation)
+ */
 export type SourcePosition = [
     /** starts with 1 */
     line: number,
     /** starts with 1 */
     column: number
 ];
+/**
+ * Describe the start and end {@link SourcePosition|source position} of an element.
+ *
+ * @see {@link rangeFrom} - to create a range
+ * @see {@link mergeRanges} - to merge multiple ranges
+ * @see {@link getRangeStart} - to get the start of a range
+ * @see {@link getRangeEnd} - to get the end of a range
+ * @see {@link rangeStartsCompletelyBefore} - to check if one range starts before another
+ * @see {@link rangesOverlap} - to check if two ranges overlap
+ * @see {@link addRanges} - to add two ranges
+ * @see {@link rangeCompare} - to compare two ranges
+ */
 export type SourceRange = [
     /** inclusive start position */
     startLine: number,
@@ -36,6 +54,9 @@ export declare function rangeStartsCompletelyBefore([, , r1el, r1ec]: SourceRang
  * Checks if the two ranges overlap.
  */
 export declare function rangesOverlap([r1sl, r1sc, r1el, r1ec]: SourceRange, [r2sl, r2sc, r2el, r2ec]: SourceRange): boolean;
+/**
+ * Calculate the component-wise sum of two ranges
+ */
 export declare function addRanges([r1sl, r1sc, r1el, r1ec]: SourceRange, [r2sl, r2sc, r2el, r2ec]: SourceRange): SourceRange;
 /**
  * Provides a comparator for {@link SourceRange}s that sorts them in ascending order.

package/util/range.js

@@ -45,6 +45,9 @@ function rangeStartsCompletelyBefore([, , r1el, r1ec], [r2sl, r2sc, ,]) {
 function rangesOverlap([r1sl, r1sc, r1el, r1ec], [r2sl, r2sc, r2el, r2ec]) {
     return r1sl <= r2el && r2sl <= r1el && r1sc <= r2ec && r2sc <= r1ec;
 }
+/**
+ * Calculate the component-wise sum of two ranges
+ */
 function addRanges([r1sl, r1sc, r1el, r1ec], [r2sl, r2sc, r2el, r2ec]) {
     return [r1sl + r2sl, r1sc + r2sc, r1el + r2el, r1ec + r2ec];
 }

package/util/version.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.flowrVersion = flowrVersion;
 const semver_1 = require("semver");
 // this is automatically replaced with the current version by release-it
-const version = '2.2.1';
+const version = '2.2.2';
 function flowrVersion() {
     return new semver_1.SemVer(version);
 }