@eagleoutice/flowr 2.0.1 → 2.0.3

package/reconstruct/reconstruct.js

@@ -129,31 +129,36 @@ function reconstructForLoop(loop, variable, vector, body, config) {
         ];
     }
 }
-function reconstructRepeatLoop(loop, body, configuration) {
-    const sel = isSelected(configuration, loop);
-    if (!sel) {
-        return body;
+function reconstructBodyWithHeader(header, body, onEmpty) {
+    if (body.length === 0) {
+        return [{ line: `${header.line}${onEmpty}`, indent: header.indent }];
     }
-    else if (body.length <= 1) {
-        // 'inline'
-        return [{ line: `repeat ${body.length === 0 ? '{}' : body[0].line}`, indent: 0 }];
+    else if (body.length === 1) {
+        return [
+            { line: `${header.line} ${body[0].line}`, indent: header.indent }
+        ];
     }
     else if (body[0].line === '{' && body[body.length - 1].line === '}') {
-        // 'block'
         return [
-            { line: 'repeat {', indent: 0 },
+            { line: `${header.line} {`, indent: header.indent },
             ...body.slice(1, body.length - 1),
-            { line: '}', indent: 0 }
+            { line: '}', indent: header.indent }
         ];
     }
     else {
-        // unknown
         return [
-            { line: 'repeat', indent: 0 },
+            header,
             ...indentBy(body, 1)
         ];
     }
 }
+function reconstructRepeatLoop(loop, body, configuration) {
+    const sel = isSelected(configuration, loop);
+    if (!sel) {
+        return body;
+    }
+    return reconstructBodyWithHeader({ line: 'repeat', indent: 0 }, body, '{}');
+}
 function reconstructIfThenElse(ifThenElse, condition, then, otherwise, config) {
     otherwise ??= [];
     if (then.length === 0 && otherwise.length === 0) {
@@ -169,10 +174,7 @@ function reconstructIfThenElse(ifThenElse, condition, then, otherwise, config) {
     }
     else if (otherwise.length === 0) {
         if (isSelected(config, ifThenElse)) {
-            return [
-                { line: `if(${getLexeme(ifThenElse.condition)}) ${then[0].line}`, indent: 0 },
-                ...indentBy(then.splice(1), 1)
-            ];
+            return reconstructBodyWithHeader({ line: `if(${getLexeme(ifThenElse.condition)})`, indent: 0 }, then, '{}');
         }
         else {
             return then;
@@ -180,10 +182,7 @@ function reconstructIfThenElse(ifThenElse, condition, then, otherwise, config) {
     }
     else if (then.length === 0) {
         if (isSelected(config, ifThenElse)) {
-            return [
-                { line: `if(${getLexeme(ifThenElse.condition)}) { } else ${otherwise[0].line}`, indent: 0 },
-                ...indentBy(otherwise.splice(1), 1)
-            ];
+            return reconstructBodyWithHeader({ line: `if(${getLexeme(ifThenElse.condition)}) { } else`, indent: 0 }, then, '{}');
         }
         else {
             return otherwise;
@@ -283,7 +282,7 @@ function reconstructFunctionDefinition(definition, functionParameters, body, con
         const empty = body === undefined || body.length === 0;
         const selected = isSelected(config, definition);
         if (empty && selected) { // give function stub
-            return plain(`function(${reconstructParameters(definition.parameters).join(', ')}) { }`);
+            return plain(`${definition.lexeme}(${reconstructParameters(definition.parameters).join(', ')}) { }`);
         }
         else if (!selected) { // do not require function
             return body;
@@ -294,25 +293,25 @@ function reconstructFunctionDefinition(definition, functionParameters, body, con
         // 'inline'
         const bodyStr = body.length === 0 ? '{ }' : `${body[0].line}`;
         // we keep the braces in every case because I do not like no-brace functions
-        return [{ line: `function(${parameters}) ${bodyStr}`, indent: 0 }];
+        return [{ line: `${definition.lexeme}(${parameters}) ${bodyStr}`, indent: 0 }];
     }
     else {
         // 'block'
         return [
-            { line: `function(${parameters}) ${body[0].line}`, indent: 0 },
+            { line: `${definition.lexeme}(${parameters}) ${body[0].line}`, indent: 0 },
             ...body.slice(1),
         ];
     }
 }
 function reconstructSpecialInfixFunctionCall(args, call) {
     (0, assert_1.guard)(args.length === 2, () => `infix special call must have exactly two arguments, got: ${args.length} (${JSON.stringify(args)})`);
-    (0, assert_1.guard)(call.flavor === 'named', `infix special call must be named, got: ${call.flavor}`);
+    (0, assert_1.guard)(call.named, `infix special call must be named, got: ${call.named}`);
     const [lhs, rhs] = args;
     if ((lhs === undefined || lhs.length === 0) && (rhs === undefined || rhs.length === 0)) {
         return [];
     }
     // else if (rhs === undefined || rhs.length === 0) {
-    // if rhs is undefined we still  have to keep both now, but reconstruct manually :/
+    // if rhs is undefined we still have to keep both now, but reconstruct manually :/
     if (lhs !== r_function_call_1.EmptyArgument && lhs.length > 0) {
         const lhsText = lhs.map(l => `${getIndentString(l.indent)}${l.line}`).join('\n');
         if (rhs !== r_function_call_1.EmptyArgument && rhs.length > 0) {
@@ -339,7 +338,7 @@ function reconstructFunctionCall(call, functionName, args, configuration) {
     if (call.infixSpecial === true) {
         return reconstructSpecialInfixFunctionCall(args, call);
     }
-    if (call.flavor === 'named' && selected) {
+    if (call.named && selected) {
         return plain(getLexeme(call));
     }
     const filteredArgs = args.filter(a => a !== undefined && a.length > 0);
@@ -349,14 +348,12 @@ function reconstructFunctionCall(call, functionName, args, configuration) {
     if (args.length === 0) {
         (0, assert_1.guard)(functionName.length > 0, `without args, we need the function name to be present! got: ${JSON.stringify(functionName)}`);
         const last = functionName[functionName.length - 1];
-        if (call.flavor === 'unnamed' && !last.line.endsWith(')')) {
+        if (!call.named && !last.line.endsWith(')')) {
             functionName[0].line = `(${functionName[0].line}`;
             last.line += ')';
         }
-        if (!last.line.endsWith('()')) {
-            // add empty call braces if not present
-            last.line += '()';
-        }
+        // add empty call braces if not present
+        last.line += '()';
         return functionName;
     }
     else {
@@ -369,7 +366,7 @@ function doNotAutoSelect(_node) {
 exports.doNotAutoSelect = doNotAutoSelect;
 const libraryFunctionCall = /^(library|require|((require|load|attach)Namespace))$/;
 function autoSelectLibrary(node) {
-    if (node.type !== "RFunctionCall" /* RType.FunctionCall */ || node.flavor !== 'named') {
+    if (node.type !== "RFunctionCall" /* RType.FunctionCall */ || !node.named) {
         return false;
     }
     return libraryFunctionCall.test(node.functionName.content);
@@ -416,13 +413,13 @@ function getIndentString(indent) {
 function prettyPrintCodeToString(code, lf = '\n') {
     return code.map(({ line, indent }) => `${getIndentString(indent)}${line}`).join(lf);
 }
-function removeOuterExpressionListIfApplicable(result, autoSelected) {
+function removeOuterExpressionListIfApplicable(result, linesWithAutoSelected) {
     if (result.length > 1 && result[0].line === '{' && result[result.length - 1].line === '}') {
         // remove outer block
-        return { code: prettyPrintCodeToString(indentBy(result.slice(1, result.length - 1), -1)), autoSelected };
+        return { code: prettyPrintCodeToString(indentBy(result.slice(1, result.length - 1), -1)), linesWithAutoSelected };
     }
     else {
-        return { code: prettyPrintCodeToString(result), autoSelected };
+        return { code: prettyPrintCodeToString(result), linesWithAutoSelected };
     }
 }
 /**
@@ -432,25 +429,27 @@ function removeOuterExpressionListIfApplicable(result, autoSelected) {
  * @param selection    - The selection of nodes to be reconstructed (probably the {@link NodeId|NodeIds} identified by the slicer)
  * @param autoSelectIf - A predicate that can be used to force the reconstruction of a node (for example to reconstruct library call statements, see {@link autoSelectLibrary}, {@link doNotAutoSelect})
  *
- * @returns The number of times `autoSelectIf` triggered, as well as the reconstructed code itself.
+ * @returns The number of lines for which `autoSelectIf` triggered, as well as the reconstructed code itself.
  */
 function reconstructToCode(ast, selection, autoSelectIf = autoSelectLibrary) {
     if (exports.reconstructLogger.settings.minLevel <= 1 /* LogLevel.Trace */) {
         exports.reconstructLogger.trace(`reconstruct ast with ids: ${JSON.stringify([...selection])}`);
     }
-    // we use a wrapper to count the number of times the autoSelectIf predicate triggered
-    let autoSelected = 0;
+    // we use a wrapper to count the number of lines for which the autoSelectIf predicate triggered
+    const linesWithAutoSelected = new Set();
     const autoSelectIfWrapper = (node) => {
         const result = autoSelectIf(node);
-        if (result) {
-            autoSelected++;
+        if (result && node.location) {
+            for (let i = node.location[0]; i <= node.location[2]; i++) {
+                linesWithAutoSelected.add(i);
+            }
         }
         return result;
     };
     // fold of the normalized ast
     const result = (0, stateful_fold_1.foldAstStateful)(ast.ast, { selection, autoSelectIf: autoSelectIfWrapper }, reconstructAstFolds);
     (0, log_1.expensiveTrace)(exports.reconstructLogger, () => `reconstructed ast before string conversion: ${JSON.stringify(result)}`);
-    return removeOuterExpressionListIfApplicable(result, autoSelected);
+    return removeOuterExpressionListIfApplicable(result, linesWithAutoSelected.size);
 }
 exports.reconstructToCode = reconstructToCode;
 //# sourceMappingURL=reconstruct.js.map

package/slicing/criterion/filters/all-variables.js

@@ -38,7 +38,7 @@ const defaultAllVariablesCollectorFolds = {
         foldFunctionDefinition: (_, a, b) => [...a.flat(), ...b],
         foldFunctionCall: (c, a, b) => {
             const args = b.flatMap(b => b !== r_function_call_1.EmptyArgument ? b.flat() : []);
-            if (c.flavor === 'named') {
+            if (c.named) {
                 return c.functionName.content === 'library' ? args.slice(1) : args;
             }
             else {

package/slicing/static/static-slicer.js

@@ -48,8 +48,8 @@ function staticSlicing(graph, ast, criteria, threshold = 75) {
         if (currentVertex.controlDependencies) {
             const topLevel = graph.isRoot(id) || sliceSeedIds.has(id);
             for (const cd of currentVertex.controlDependencies) {
-                if (!topLevel || (ast.idMap.get(cd)?.info.depth ?? 0) <= minDepth) {
-                    queue.add(cd, baseEnvironment, baseEnvFingerprint, false);
+                if (!topLevel || (ast.idMap.get(cd.id)?.info.depth ?? 0) <= minDepth) {
+                    queue.add(cd.id, baseEnvironment, baseEnvFingerprint, false);
                 }
             }
         }

package/statistics/features/common-syntax-probability.js

@@ -79,7 +79,7 @@ function updateCommonSyntaxTypeCounts(current, ...nodes) {
             }
             break;
         case "RFunctionCall" /* RType.FunctionCall */:
-            if (node.flavor === 'unnamed') {
+            if (!node.named) {
                 current.unnamedCall++;
             }
             else {

package/statistics/features/supported/control-flow/control-flow.js

@@ -21,7 +21,7 @@ function visitIfThenElse(info, input) {
     const ifThenElseStack = [];
     (0, visitor_1.visitAst)(input.normalizedRAst.ast, node => {
         if (node.type !== "RIfThenElse" /* RType.IfThenElse */) {
-            if (node.type === "RFunctionCall" /* RType.FunctionCall */ && node.flavor === 'named' && node.functionName.content === 'switch') {
+            if (node.type === "RFunctionCall" /* RType.FunctionCall */ && node.named && node.functionName.content === 'switch') {
                 const initialArg = (0, unpack_argument_1.unpackArgument)(node.arguments[0]);
                 if (initialArg) {
                     info.switchCase = (0, common_syntax_probability_1.updateCommonSyntaxTypeCounts)(info.switchCase, initialArg);

package/statistics/features/supported/defined-functions/defined-functions.js

@@ -100,7 +100,7 @@ function visitDefinitions(info, input) {
         // track all calls with the same name that do not already have a bound calls edge, superfluous if recursive tracking is explicit
         const recursiveCalls = [];
         (0, visitor_1.visitAst)(node.body, n => {
-            if (n.type === "RFunctionCall" /* RType.FunctionCall */ && n.flavor === 'named' && assigned.has(n.functionName.lexeme)) {
+            if (n.type === "RFunctionCall" /* RType.FunctionCall */ && n.named && assigned.has(n.functionName.lexeme)) {
                 recursiveCalls.push(n);
             }
         });

package/statistics/features/supported/loops/loops.js

@@ -33,7 +33,7 @@ function visitLoops(info, input) {
                 info.breakStatements++;
                 return;
             case "RFunctionCall" /* RType.FunctionCall */:
-                if (node.flavor === 'named' && isImplicitLoop.test(node.functionName.lexeme)) {
+                if (node.named && isImplicitLoop.test(node.functionName.lexeme)) {
                     info.implicitLoops++;
                     (0, statistics_file_1.appendStatisticsFile)(exports.loops.name, 'implicit-loop', [node.functionName.info.fullLexeme ?? node.functionName.lexeme], input.filepath);
                 }

package/statistics/features/supported/used-functions/used-functions.js

@@ -63,7 +63,7 @@ function visitCalls(info, input) {
         if (dataflowNode) {
             hasCallsEdge = [...dataflowNode[1].values()].some(e => (0, edge_1.edgeIncludesType)(e.types, 4 /* EdgeType.Calls */));
         }
-        if (node.flavor === 'unnamed') {
+        if (!node.named) {
             info.unnamedCalls++;
             (0, statistics_file_1.appendStatisticsFile)(exports.usedFunctions.name, 'unnamed-calls', [node.lexeme], input.filepath);
             allCalls.push([

package/util/assert.d.ts

@@ -9,4 +9,4 @@ export type GuardMessage = string | (() => string);
  * @param message - if a string, will be used as error message, if a function, will be called to produce the error message (can be used to avoid costly message generations)
  * @throws GuardError - if the assertion fails
  */
-export declare function guard(assertion: boolean, message?: GuardMessage): asserts assertion;
+export declare function guard(assertion: boolean | undefined, message?: GuardMessage): asserts assertion;

package/util/mermaid/ast.js

@@ -13,6 +13,10 @@ function normalizedAstToMermaid(ast, prefix = '') {
             const roleSuffix = context.role === "expr-list-child" /* RoleInParent.ExpressionListChild */ || context.role === "call-argument" /* RoleInParent.FunctionCallArgument */ || context.role === "function-def-param" /* RoleInParent.FunctionDefinitionParameter */ ? `-${context.index}` : '';
             output += `    n${n.info.parent} -->|"${context.role}${roleSuffix}"| n${n.info.id}\n`;
         }
+        if (n.type === "RExpressionList" /* RType.ExpressionList */ && n.grouping !== undefined) {
+            output += `    n${n.info.id} -.-|"group-open"| n${n.grouping[0].info.id}\n`;
+            output += `    n${n.info.id} -.-|"group-close"| n${n.grouping[1].info.id}\n`;
+        }
         return false;
     });
     return output;

package/util/mermaid/dfg.d.ts

@@ -7,7 +7,6 @@ type Mark = MarkVertex | MarkEdge;
 interface MermaidGraph {
     nodeLines: string[];
     edgeLines: string[];
-    hasBuiltIn: boolean;
     includeEnvironments: boolean;
     mark: ReadonlySet<Mark> | undefined;
     /** in the form of from-\>to because I am lazy, see {@link encodeEdge} */

package/util/mermaid/dfg.js

@@ -7,11 +7,18 @@ const graph_1 = require("../../dataflow/graph/graph");
 const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const edge_1 = require("../../dataflow/graph/edge");
 const environment_1 = require("../../dataflow/environments/environment");
-const built_in_1 = require("../../dataflow/environments/built-in");
 function formatRange(range) {
     if (range === undefined) {
         return '??-??';
     }
+    else if (range[0] === range[2]) {
+        if (range[1] === range[3]) {
+            return `${range[0]}.${range[1]}`;
+        }
+        else {
+            return `${range[0]}.${range[1]}-${range[3]}`;
+        }
+    }
     return `${range[0]}.${range[1]}-${range[2]}.${range[3]}`;
 }
 exports.formatRange = formatRange;
@@ -102,7 +109,7 @@ function printEnvironmentToLines(env) {
     else if (env.id === environment_1.BuiltInEnvironment.id) {
         return ['Built-in'];
     }
-    const lines = [...printEnvironmentToLines(env.parent), `${env.id}--${env.name}${'-'.repeat(40)}`];
+    const lines = [...printEnvironmentToLines(env.parent), `${env.id}${'-'.repeat(40)}`];
     const longestName = Math.max(...[...env.memory.keys()].map(x => x.length));
     for (const [name, defs] of env.memory.entries()) {
         const printName = `${name}:`;
@@ -119,15 +126,17 @@ function vertexToMermaid(info, mermaid, id, idPrefix, mark) {
         }
     }
     const node = mermaid.rootGraph.idMap?.get(info.id);
-    const escapedName = (0, mermaid_1.escapeMarkdown)(node ? `[${node.type}] ${node.lexeme ?? '??'}` : '??');
+    const lexeme = node?.lexeme ?? (node?.type === "RExpressionList" /* RType.ExpressionList */ ? node?.grouping?.[0]?.lexeme : '') ?? '??';
+    const escapedName = (0, mermaid_1.escapeMarkdown)(node ? `[${node.type}] ${lexeme}` : '??');
     const deps = info.controlDependencies ? ', :maybe:' + info.controlDependencies.join(',') : '';
-    mermaid.nodeLines.push(`    ${idPrefix}${id}${open}"\`${escapedName}${escapedName.length > 10 ? '\n      ' : ' '}(${id}${deps})\n      *${formatRange(mermaid.rootGraph.idMap?.get(id)?.location)}*${fCall ? displayFunctionArgMapping(info.args) : ''}\`"${close}`);
+    const n = node?.info.fullRange ?? node?.location ?? (node?.type === "RExpressionList" /* 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} stroke:black,stroke-width:7px; `);
     }
     const edges = mermaid.rootGraph.get(id, true);
     (0, assert_1.guard)(edges !== undefined, `node ${id} must be found`);
-    const artificialCdEdges = (info.controlDependencies ?? []).map(x => [x, { types: new Set(['CD']) }]);
+    const artificialCdEdges = (info.controlDependencies ?? []).map(x => [x.id, { types: new Set([x.when ? 'CD-True' : 'CD-False']) }]);
     for (const [target, edge] of [...edges[1], ...artificialCdEdges]) {
         const edgeTypes = typeof edge.types == 'number' ? new Set((0, edge_1.splitEdgeTypes)(edge.types)) : edge.types;
         const edgeId = encodeEdge(idPrefix + id, idPrefix + target, edgeTypes);
@@ -138,12 +147,9 @@ function vertexToMermaid(info, mermaid, id, idPrefix, mark) {
                 // who invented this syntax?!
                 mermaid.edgeLines.push(`    linkStyle ${mermaid.presentEdges.size - 1} stroke:red,color:red,stroke-width:4px;`);
             }
-            if (edgeTypes.has('CD')) {
+            if (edgeTypes.has('CD-True')) {
                 mermaid.edgeLines.push(`    linkStyle ${mermaid.presentEdges.size - 1} stroke:gray,color:gray;`);
             }
-            if (target === built_in_1.BuiltIn) {
-                mermaid.hasBuiltIn = true;
-            }
         }
     }
     if (info.tag === 'function-definition') {
@@ -152,15 +158,12 @@ 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() }) {
-    const mermaid = { nodeLines: prefix === null ? [] : [prefix], edgeLines: [], presentEdges, hasBuiltIn: false, mark, rootGraph: rootGraph ?? graph, includeEnvironments };
+    const mermaid = { nodeLines: prefix === null ? [] : [prefix], edgeLines: [], presentEdges, mark, rootGraph: rootGraph ?? graph, includeEnvironments };
     for (const [id, info] of graph.vertices(true)) {
         if (rootIds.has(id)) {
             vertexToMermaid(info, mermaid, id, idPrefix, mark);
         }
     }
-    if (mermaid.hasBuiltIn) {
-        mermaid.nodeLines.push(`    ${idPrefix}${built_in_1.BuiltIn}["Built-in"]`);
-    }
     return mermaid;
 }
 function graphToMermaid(config) {

package/util/mermaid/mermaid.js

@@ -1,8 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mermaidCodeToUrl = exports.escapeMarkdown = void 0;
+const replacements = {
+    // keep newlines
+    '\\n': '\n',
+    '`': '#96;',
+    '[': '#91;',
+    ']': '#93;',
+    '<': '#60;',
+    '>': '#62;',
+    '*': '#42;',
+    '+': '#43;',
+    '-': '#45;',
+    '"': '#34;',
+    '\\': '#92;',
+    '_': '#95;',
+    '{': '#123;',
+    '}': '#125;'
+};
 function escapeMarkdown(text) {
-    return text.replaceAll(/([+*<>-])/g, '\\$1').replaceAll('"', '\'\'');
+    for (const [key, value] of Object.entries(replacements)) {
+        text = text.replaceAll(key, value);
+    }
+    return text;
 }
 exports.escapeMarkdown = escapeMarkdown;
 /**

package/util/version.js

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