@eagleoutice/flowr 2.0.0 → 2.0.2

package/dataflow/internal/process/functions/call/built-in/built-in-get.js

@@ -24,12 +24,17 @@ function processGet(name, args, rootId, data) {
         location: retrieve.location,
         namespace: undefined
     };
-    const { information } = (0, known_call_handling_1.processKnownFunctionCall)({
+    const { information, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({
         name,
         args: (0, make_argument_1.wrapArgumentsUnnamed)([treatTargetAsSymbol], data.completeAst.idMap),
         rootId,
         data
     });
+    const firstArg = processedArguments[0];
+    if (firstArg) {
+        // get 'reads' its first argument
+        information.graph.addEdge(rootId, firstArg.entryPoint, { type: 1 /* EdgeType.Reads */ });
+    }
     return information;
 }
 exports.processGet = processGet;

package/dataflow/internal/process/functions/call/built-in/built-in-if-then-else.js

@@ -57,21 +57,23 @@ function processIfThenElse(name, args, rootId, data) {
     const thenEnvironment = then?.environment ?? cond.environment;
     // if there is no "else" case, we have to recover whatever we had before as it may be not executed
     const finalEnvironment = (0, append_1.appendEnvironment)(thenEnvironment, otherwise ? otherwise.environment : cond.environment);
+    const cdTrue = { id: rootId, when: true };
+    const cdFalse = { id: rootId, when: false };
     // again within an if-then-else we consider all actives to be read
     const ingoing = [
         ...cond.in,
-        ...(makeThenMaybe ? (0, environment_1.makeAllMaybe)(then?.in, nextGraph, finalEnvironment, false, rootId) : then?.in ?? []),
-        ...(makeOtherwiseMaybe ? (0, environment_1.makeAllMaybe)(otherwise?.in, nextGraph, finalEnvironment, false, rootId) : otherwise?.in ?? []),
+        ...(makeThenMaybe ? (0, environment_1.makeAllMaybe)(then?.in, nextGraph, finalEnvironment, false, cdTrue) : then?.in ?? []),
+        ...(makeOtherwiseMaybe ? (0, environment_1.makeAllMaybe)(otherwise?.in, nextGraph, finalEnvironment, false, cdFalse) : otherwise?.in ?? []),
         ...cond.unknownReferences,
-        ...(makeThenMaybe ? (0, environment_1.makeAllMaybe)(then?.unknownReferences, nextGraph, finalEnvironment, false, rootId) : then?.unknownReferences ?? []),
-        ...(makeOtherwiseMaybe ? (0, environment_1.makeAllMaybe)(otherwise?.unknownReferences, nextGraph, finalEnvironment, false, rootId) : otherwise?.unknownReferences ?? []),
+        ...(makeThenMaybe ? (0, environment_1.makeAllMaybe)(then?.unknownReferences, nextGraph, finalEnvironment, false, cdTrue) : then?.unknownReferences ?? []),
+        ...(makeOtherwiseMaybe ? (0, environment_1.makeAllMaybe)(otherwise?.unknownReferences, nextGraph, finalEnvironment, false, cdFalse) : otherwise?.unknownReferences ?? []),
     ];
     // we assign all with a maybe marker
     // we do not merge even if they appear in both branches because the maybe links will refer to different ids
     const outgoing = [
         ...cond.out,
-        ...(makeThenMaybe ? (0, environment_1.makeAllMaybe)(then?.out, nextGraph, finalEnvironment, true, rootId) : then?.out ?? []),
-        ...(makeOtherwiseMaybe ? (0, environment_1.makeAllMaybe)(otherwise?.out, nextGraph, finalEnvironment, true, rootId) : otherwise?.out ?? []),
+        ...(makeThenMaybe ? (0, environment_1.makeAllMaybe)(then?.out, nextGraph, finalEnvironment, true, cdTrue) : then?.out ?? []),
+        ...(makeOtherwiseMaybe ? (0, environment_1.makeAllMaybe)(otherwise?.out, nextGraph, finalEnvironment, true, cdFalse) : otherwise?.out ?? []),
     ];
     (0, common_1.patchFunctionCall)({
         nextGraph,
@@ -83,8 +85,8 @@ function processIfThenElse(name, args, rootId, data) {
     // as an if always evaluates its condition, we add a 'reads'-edge
     nextGraph.addEdge(name.info.id, cond.entryPoint, { type: 1 /* EdgeType.Reads */ });
     const exitPoints = [
-        ...(then?.exitPoints ?? []).map(e => ({ ...e, controlDependencies: makeThenMaybe ? [...data.controlDependencies ?? []] : e.controlDependencies })),
-        ...(otherwise?.exitPoints ?? []).map(e => ({ ...e, controlDependencies: makeOtherwiseMaybe ? [...data.controlDependencies ?? []] : e.controlDependencies }))
+        ...(then?.exitPoints ?? []).map(e => ({ ...e, controlDependencies: makeThenMaybe ? [...data.controlDependencies ?? [], { id: rootId, when: true }] : e.controlDependencies })),
+        ...(otherwise?.exitPoints ?? []).map(e => ({ ...e, controlDependencies: makeOtherwiseMaybe ? [...data.controlDependencies ?? [], { id: rootId, when: false }] : e.controlDependencies }))
     ];
     return {
         unknownReferences: [],

package/dataflow/internal/process/functions/call/built-in/built-in-logical-bin-op.d.ts

@@ -6,4 +6,5 @@ import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/node
 import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 export declare function processSpecialBinOp<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
     lazy: boolean;
+    evalRhsWhen: boolean;
 }): DataflowInformation;

package/dataflow/internal/process/functions/call/built-in/built-in-logical-bin-op.js

@@ -14,8 +14,7 @@ function processSpecialBinOp(name, args, rootId, data, config) {
     const { information, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data,
         patchData: (d, i) => {
             if (i === 1) {
-                // the rhs will be overshadowed by the lhs
-                return { ...d, controlDependencies: [...d.controlDependencies ?? [], name.info.id] };
+                return { ...d, controlDependencies: [...d.controlDependencies ?? [], { id: name.info.id, when: config.evalRhsWhen }] };
             }
             return d;
         }

package/dataflow/internal/process/functions/call/built-in/built-in-while-loop.js

@@ -28,7 +28,7 @@ function processWhileLoop(name, args, rootId, data) {
         markAsNSE: [1],
         patchData: (d, i) => {
             if (i === 1) {
-                return { ...d, controlDependencies: [...d.controlDependencies ?? [], name.info.id] };
+                return { ...d, controlDependencies: [...d.controlDependencies ?? [], { id: name.info.id, when: true }] };
             }
             return d;
         }

package/dataflow/internal/process/functions/call/default-call-handling.js

@@ -4,7 +4,7 @@ exports.processFunctionCall = void 0;
 const named_call_handling_1 = require("./named-call-handling");
 const unnamed_call_handling_1 = require("./unnamed-call-handling");
 function processFunctionCall(functionCall, data) {
-    if (functionCall.flavor === 'named') {
+    if (functionCall.named) {
         return (0, named_call_handling_1.processNamedCall)(functionCall.functionName, functionCall.arguments, functionCall.info.id, data);
     }
     else {

package/dataflow/internal/process/functions/call/unnamed-call-handling.js

@@ -50,7 +50,7 @@ function processUnnamedFunctionCall(functionCall, data) {
         out: calledFunction.out,
         graph: finalGraph,
         environment: finalEnv,
-        entryPoint: calledRootId,
+        entryPoint: functionCall.info.id,
         exitPoints: calledFunction.exitPoints
     };
 }

package/dataflow/processor.d.ts

@@ -1,11 +1,10 @@
 /**
  * Based on a two-way fold, this processor will automatically supply scope information
  */
-import type { DataflowInformation } from './info';
+import type { ControlDependency, DataflowInformation } from './info';
 import type { NormalizedAst, ParentInformation, RNodeWithParent } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { REnvironmentInformation } from './environments/environment';
 import type { RParseRequest } from '../r-bridge/retriever';
-import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { RNode } from '../r-bridge/lang-4.x/ast/model/model';
 export interface DataflowProcessorInformation<OtherInfo> {
     /**
@@ -33,7 +32,7 @@ export interface DataflowProcessorInformation<OtherInfo> {
     /**
      * The chain of control-flow {@link NodeId}s that lead to the current node (e.g. of known ifs).
      */
-    readonly controlDependencies: NodeId[] | undefined;
+    readonly controlDependencies: ControlDependency[] | undefined;
 }
 export type DataflowProcessor<OtherInfo, NodeType extends RNodeWithParent<OtherInfo>> = (node: NodeType, data: DataflowProcessorInformation<OtherInfo>) => DataflowInformation;
 type NodeWithKey<OtherInfo, Key> = RNode<OtherInfo & ParentInformation> & {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/flowr",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "Static Dataflow Analyzer and Program Slicer for the R Programming Language",
   "types": "dist/src/index.d.ts",
   "repository": {
@@ -12,7 +12,7 @@
     "url": "https://github.com/Code-Inspect/flowr/issues"
   },
   "scripts": {
-    "main": "npm run build && node dist/src/cli/flowr.js",
+    "main": "npm run build:bundle-flowr && node dist/src/cli/flowr.min.js",
     "publish-library": "cp .npmignore package.json README.md LICENSE dist/src/ && cd dist/src && npm publish --access public",
     "release": "npx release-it --ci",
     "stats": "ts-node src/cli/statistics-app.ts",
@@ -24,6 +24,7 @@
     "export-quads": "ts-node src/cli/export-quads-app.ts",
     "capabilities-markdown": "ts-node src/r-bridge/data/print.ts",
     "build": "tsc --project .",
+    "build:bundle-flowr": "npm run build && esbuild --bundle dist/src/cli/flowr.js --platform=node --bundle --minify --target=node18 --outfile=dist/src/cli/flowr.min.js",
     "lint-local": "npx eslint --version && npx eslint src/ test/ --rule \"no-warning-comments: off\"",
     "lint": "npm run license-compat -- --summary && npx eslint --version && npx eslint src/ test/",
     "license-compat": "license-checker --onlyAllow 'MIT;MIT OR X11;GPLv2;LGPL;GNUGPL;ISC;Apache-2.0;FreeBSD;BSD-2-Clause;clearbsd;ModifiedBSD;BSD-3-Clause;Python-2.0;Unlicense;WTFPL;BlueOak-1.0.0;CC-BY-4.0;CC-BY-3.0;CC0-1.0;0BSD'",
@@ -200,6 +201,7 @@
     "@typescript-eslint/eslint-plugin": "^7.8.0",
     "chai": "^4.3.16",
     "chai-as-promised": "^7.1.1",
+    "esbuild": "0.21.3",
     "eslint": "^8.57.0",
     "eslint-plugin-check-file": "^2.8.0",
     "eslint-plugin-import": "^2.29.1",

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

@@ -373,7 +373,7 @@ export declare const flowrCapabilities: {
                     readonly name: "Sequencing";
                     readonly id: "built-in-sequencing";
                     readonly supported: "not";
-                    readonly description: "_Handle `:`, `seq`, ... as they are used often._";
+                    readonly description: "_Handle `:`, `seq`, ... by gathering value information using abstract interpretation._";
                 }, {
                     readonly name: "Internal and Primitive Functions";
                     readonly id: "built-in-internal-and-primitive-functions";

package/r-bridge/data/data.js

@@ -464,7 +464,7 @@ exports.flowrCapabilities = {
                                     name: 'Sequencing',
                                     id: 'built-in-sequencing',
                                     supported: 'not',
-                                    description: '_Handle `:`, `seq`, ... as they are used often._'
+                                    description: '_Handle `:`, `seq`, ... by gathering value information using abstract interpretation._'
                                 },
                                 {
                                     name: 'Internal and Primitive Functions',

package/r-bridge/lang-4.x/ast/model/nodes/r-function-call.d.ts

@@ -11,7 +11,7 @@ export type RFunctionArgument<Info = NoInfo> = RArgument<Info> | typeof EmptyArg
  */
 export interface RNamedFunctionCall<Info = NoInfo> extends Base<Info>, Location {
     readonly type: RType.FunctionCall;
-    readonly flavor: 'named';
+    readonly named: true;
     functionName: RSymbol<Info>;
     /** arguments can be empty, for example when calling as `a(1, ,3)` */
     readonly arguments: readonly RFunctionArgument<Info>[];
@@ -23,7 +23,7 @@ export interface RNamedFunctionCall<Info = NoInfo> extends Base<Info>, Location
  */
 export interface RUnnamedFunctionCall<Info = NoInfo> extends Base<Info>, Location {
     readonly type: RType.FunctionCall;
-    readonly flavor: 'unnamed';
+    readonly named: false | undefined;
     calledFunction: RNode<Info>;
     /** marks function calls like `3 %xx% 4` which have been written in special infix notation; deprecated in v2 */
     infixSpecial?: boolean;

package/r-bridge/lang-4.x/ast/model/operators.js

@@ -41,7 +41,7 @@ exports.OperatorDatabase = {
     '=': { name: 'equal assignment', stringUsedInRAst: "EQ_ASSIGN" /* RawRType.EqualAssign */, stringUsedInternally: '=', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'assignment', capabilities: ['binary-operator', 'infix-calls', 'assignment-functions', 'local-equal-assignment', 'function-calls'] },
     /* others */
     /* maybe introduce custom in-r-ast flavor for these? we consider it arithmetic, as it works on numbers => if we change this we have to create custom tests! (with arithmetic, there is the automatic test set) */
-    ':': { name: 'sequence operator', stringUsedInRAst: ":" /* RawRType.Colon */, stringUsedInternally: ':', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'function-calls', 'built-in-sequencing'] },
+    ':': { name: 'sequence operator', stringUsedInRAst: ":" /* RawRType.Colon */, stringUsedInternally: ':', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'function-calls'] },
     '?': { name: 'question', stringUsedInRAst: "?" /* RawRType.Question */, stringUsedInternally: '?', writtenAs: 'prefix', arity: 1 /* OperatorArity.Unary */, usedAs: 'operation', capabilities: ['unary-operator', 'built-in-help'] }
 };
 /* eslint-enable */

package/r-bridge/lang-4.x/ast/model/processing/decorate.js

@@ -269,7 +269,7 @@ function createFoldForFunctionCall(info) {
     return (data, functionName, args, depth) => {
         const id = info.getId(data);
         let decorated;
-        if (data.flavor === 'named') {
+        if (data.named) {
             decorated = { ...data, info: { ...data.info, id, parent: undefined, depth }, functionName, arguments: args };
         }
         else {

package/r-bridge/lang-4.x/ast/model/processing/stateful-fold.js

@@ -37,7 +37,7 @@ function foldAstStateful(ast, down, folds) {
         case "RRepeatLoop" /* RType.RepeatLoop */:
             return folds.loop.foldRepeat(ast, foldAstStateful(ast.body, down, folds), down);
         case "RFunctionCall" /* RType.FunctionCall */:
-            return folds.functions.foldFunctionCall(ast, foldAstStateful(ast.flavor === 'named' ? ast.functionName : ast.calledFunction, down, folds), ast.arguments.map(param => param === r_function_call_1.EmptyArgument ? param : foldAstStateful(param, down, folds)), down);
+            return folds.functions.foldFunctionCall(ast, foldAstStateful(ast.named ? ast.functionName : ast.calledFunction, down, folds), ast.arguments.map(param => param === r_function_call_1.EmptyArgument ? param : foldAstStateful(param, down, folds)), down);
         case "RFunctionDefinition" /* RType.FunctionDefinition */:
             return folds.functions.foldFunctionDefinition(ast, ast.parameters.map(param => foldAstStateful(param, down, folds)), foldAstStateful(ast.body, down, folds), down);
         case "RParameter" /* RType.Parameter */:

package/r-bridge/lang-4.x/ast/model/processing/visitor.js

@@ -15,11 +15,11 @@ class NodeVisitor {
         if (this.onEnter?.(node)) {
             return;
         }
-        /* let the type system know, that the type does not change */
+        /* let the type system know that the type does not change */
         const type = node.type;
         switch (type) {
             case "RFunctionCall" /* RType.FunctionCall */:
-                this.visitSingle(node.flavor === 'named' ? node.functionName : node.calledFunction);
+                this.visitSingle(node.named ? node.functionName : node.calledFunction);
                 this.visit(node.arguments);
                 break;
             case "RFunctionDefinition" /* RType.FunctionDefinition */:

package/r-bridge/lang-4.x/ast/parser/xml/internal/functions/normalize-call.js

@@ -96,7 +96,7 @@ function tryParseUnnamedFunctionCall(data, mappedWithName, location, content) {
     }
     return {
         type: "RFunctionCall" /* RType.FunctionCall */,
-        flavor: 'unnamed',
+        named: undefined,
         location,
         lexeme: content,
         calledFunction: calledFunction,
@@ -129,7 +129,7 @@ function parseNamedFunctionCall(data, symbolContent, mappedWithName, location, c
     const parsedArguments = parseArguments(mappedWithName, data);
     return {
         type: "RFunctionCall" /* RType.FunctionCall */,
-        flavor: 'named',
+        named: true,
         location,
         lexeme: content,
         functionName,

package/r-bridge/lang-4.x/ast/parser/xml/internal/operators/normalize-binary.js

@@ -37,7 +37,7 @@ function parseBinaryOp(data, lhs, operator, rhs) {
         // parse as infix function call!
         return {
             type: "RFunctionCall" /* RType.FunctionCall */,
-            flavor: 'named',
+            named: true,
             infixSpecial: true,
             lexeme: data.currentLexeme ?? content,
             location,

package/r-bridge/retriever.d.ts

@@ -49,4 +49,4 @@ export declare function removeRQuotes(str: string): string;
 /**
  * Needs to be called *after*  {@link retrieveParseDataFromRCode} (or {@link retrieveNormalizedAstFromRCode})
  */
-export declare function retrieveNumberOfRTokensOfLastParse(shell: RShell): Promise<number>;
+export declare function retrieveNumberOfRTokensOfLastParse(shell: RShell, ignoreComments?: boolean): Promise<number>;

package/r-bridge/retriever.js

@@ -95,8 +95,9 @@ exports.removeRQuotes = removeRQuotes;
 /**
  * Needs to be called *after*  {@link retrieveParseDataFromRCode} (or {@link retrieveNormalizedAstFromRCode})
  */
-async function retrieveNumberOfRTokensOfLastParse(shell) {
-    const result = await shell.sendCommandWithOutput(`cat(nrow(flowr_output),${(0, convert_values_1.ts2r)(shell.options.eol)})`);
+async function retrieveNumberOfRTokensOfLastParse(shell, ignoreComments = false) {
+    const rows = ignoreComments ? `flowr_output[flowr_output$token != "${"COMMENT" /* RawRType.Comment */}", ]` : 'flowr_output';
+    const result = await shell.sendCommandWithOutput(`cat(nrow(${rows}),${(0, convert_values_1.ts2r)(shell.options.eol)})`);
     (0, assert_1.guard)(result.length === 1, () => `expected exactly one line to obtain the number of R tokens, but got: ${JSON.stringify(result)}`);
     return Number(result[0]);
 }

package/r-bridge/shell.js

@@ -27,7 +27,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RShell = exports.DEFAULT_R_SHELL_OPTIONS = exports.DEFAULT_R_SHELL_EXEC_OPTIONS = exports.DEFAULT_R_PATH = exports.DEFAULT_OUTPUT_COLLECTOR_CONFIGURATION = void 0;
-const node_child_process_1 = require("node:child_process");
+const child_process_1 = require("child_process");
 const objects_1 = require("../util/objects");
 const readline = __importStar(require("readline"));
 const log_1 = require("../util/log");
@@ -196,7 +196,8 @@ class RShell {
    */
     clearEnvironment() {
         this.log.debug('clearing environment');
-        this._sendCommand('rm(list=ls())');
+        // run rm(list=ls()) but ignore 'flowr_get_ast', which is the compile command installed
+        this._sendCommand('rm(list=setdiff(ls(), "flowr_get_ast"))');
     }
     /**
      * Obtain the temporary directory used by R.
@@ -231,7 +232,7 @@ class RShellSession {
     options;
     collectionTimeout;
     constructor(options, log) {
-        this.bareSession = (0, node_child_process_1.spawn)(options.pathToRExecutable, options.commandLineOptions, {
+        this.bareSession = (0, child_process_1.spawn)(options.pathToRExecutable, options.commandLineOptions, {
             env: options.env,
             cwd: options.cwd,
             windowsHide: true

package/reconstruct/reconstruct.d.ts

@@ -14,8 +14,8 @@ export declare function doNotAutoSelect(_node: RNode<ParentInformation>): boolea
 export declare function autoSelectLibrary(node: RNode<ParentInformation>): boolean;
 export interface ReconstructionResult {
     code: string;
-    /** number of nodes that triggered the `autoSelectIf` predicate {@link reconstructToCode} */
-    autoSelected: number;
+    /** number of lines that contain nodes that triggered the `autoSelectIf` predicate {@link reconstructToCode} */
+    linesWithAutoSelected: number;
 }
 /**
  * Reconstructs parts of a normalized R ast into R code on an expression basis.
@@ -24,7 +24,7 @@ export interface ReconstructionResult {
  * @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.
  */
 export declare function reconstructToCode<Info>(ast: NormalizedAst<Info>, selection: Selection, autoSelectIf?: AutoSelectPredicate): ReconstructionResult;
 export {};

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);
                 }