@eagleoutice/flowr 2.0.1 → 2.0.3

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

@@ -39,7 +39,7 @@ args, rootId, data, config) {
     }
     const effectiveArgs = getEffectiveOrder(config, args);
     const { target, source } = extractSourceAndTarget(effectiveArgs, name);
-    const { type, flavor } = target;
+    const { type, named } = target;
     if (type === "RSymbol" /* RType.Symbol */) {
         const res = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, reverseOrder: !config.swapSourceAndTarget });
         return processAssignmentToSymbol({
@@ -53,7 +53,7 @@ args, rootId, data, config) {
             information: res.information,
         });
     }
-    else if (config.canBeReplacement && type === "RFunctionCall" /* RType.FunctionCall */ && flavor === 'named') {
+    else if (config.canBeReplacement && type === "RFunctionCall" /* RType.FunctionCall */ && named) {
         /* as replacement functions take precedence over the lhs fn-call (i.e., `names(x) <- ...` is independent from the definition of `names`), we do not have to process the call */
         logger_1.dataflowLogger.debug(`Assignment ${name.content} has a function call as target => replacement function ${target.lexeme}`);
         const replacement = toReplacementSymbol(target, target.functionName.content, config.superAssignment ?? false);
@@ -132,7 +132,7 @@ function processAssignmentToSymbol({ name, source, args: [targetArg, sourceArg],
     }
     // we drop the first arg which we use to pass along arguments :D
     const readFromSourceWritten = sourceArg.out.slice(1);
-    const readTargets = [{ nodeId: name.info.id, name: name.content, controlDependencies: data.controlDependencies }, ...sourceArg.unknownReferences, ...sourceArg.in, ...targetArg.in.filter(i => i.nodeId !== target.info.id), ...readFromSourceWritten];
+    const readTargets = [{ nodeId: rootId, name: name.content, controlDependencies: data.controlDependencies }, ...sourceArg.unknownReferences, ...sourceArg.in, ...targetArg.in.filter(i => i.nodeId !== target.info.id), ...readFromSourceWritten];
     const writeTargets = [...writeNodes, ...writeNodes, ...readFromSourceWritten];
     information.environment = (0, overwrite_1.overwriteEnvironment)(targetArg.environment, sourceArg.environment);
     // install assigned variables in environment
@@ -152,14 +152,14 @@ function processAssignmentToSymbol({ name, source, args: [targetArg, sourceArg],
             }
         }
     }
-    information.graph.addEdge(name.info.id, targetArg.entryPoint, { type: 8 /* EdgeType.Returns */ });
+    information.graph.addEdge(rootId, targetArg.entryPoint, { type: 8 /* EdgeType.Returns */ });
     if (quoteSource) {
         information.graph.addEdge(rootId, source.info.id, { type: 256 /* EdgeType.NonStandardEvaluation */ });
     }
     return {
         ...information,
         unknownReferences: [],
-        entryPoint: name.info.id,
+        entryPoint: rootId,
         in: readTargets,
         out: writeTargets
     };

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

@@ -29,7 +29,7 @@ function processForLoop(name, args, rootId, data) {
     const variable = (0, processor_1.processDataflowFor)(variableArg, data);
     // this should not be able to exit always!
     const originalDependency = data.controlDependencies;
-    data = { ...data, controlDependencies: [...data.controlDependencies ?? [], name.info.id] };
+    data = { ...data, controlDependencies: [...data.controlDependencies ?? [], { id: name.info.id, when: true }] };
     let headEnvironments = (0, overwrite_1.overwriteEnvironment)(vector.environment, variable.environment);
     const headGraph = variable.graph.mergeWith(vector.graph);
     const writtenVariable = [...variable.unknownReferences, ...variable.in];

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

@@ -13,6 +13,7 @@ const overwrite_1 = require("../../../../../environments/overwrite");
 const scoping_1 = require("../../../../../environments/scoping");
 const environment_1 = require("../../../../../environments/environment");
 const resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
+const log_1 = require("../../../../../../util/log");
 function processFunctionDefinition(name, args, rootId, data) {
     if (args.length < 1) {
         logger_1.dataflowLogger.warn(`Function Definition ${name.content} does not have an argument, skipping`);
@@ -53,7 +54,7 @@ function processFunctionDefinition(name, args, rootId, data) {
                 tag: "use" /* VertexType.Use */,
                 id: read.nodeId,
                 environment: undefined,
-                controlDependencies: []
+                controlDependencies: undefined
             });
         }
     }
@@ -65,8 +66,8 @@ function processFunctionDefinition(name, args, rootId, data) {
         graph: new Set(subgraph.rootIds()),
         environment: outEnvironment
     };
+    updateNestedFunctionClosures(subgraph, outEnvironment, name);
     const exitPoints = body.exitPoints;
-    updateNestedFunctionClosures(exitPoints, subgraph, outEnvironment, name);
     const graph = new graph_1.DataflowGraph(data.completeAst.idMap).mergeWith(subgraph, false);
     graph.addVertex({
         tag: "function-definition" /* VertexType.FunctionDefinition */,
@@ -88,33 +89,28 @@ function processFunctionDefinition(name, args, rootId, data) {
     };
 }
 exports.processFunctionDefinition = processFunctionDefinition;
-function updateNestedFunctionClosures(exitPoints, subgraph, outEnvironment, name) {
-    // track *all* function definitions - including those nested within the current graph
+function updateNestedFunctionClosures(subgraph, outEnvironment, name) {
+    // track *all* function definitions - including those nested within the current graph,
     // try to resolve their 'in' by only using the lowest scope which will be popped after this definition
-    for (const [id, info] of subgraph.vertices(true)) {
-        if (info.tag !== "function-definition" /* VertexType.FunctionDefinition */) {
+    for (const [id, { subflow, tag }] of subgraph.vertices(true)) {
+        if (tag !== "function-definition" /* VertexType.FunctionDefinition */) {
             continue;
         }
-        const ingoingRefs = info.subflow.in;
-        const remainingIn = new Set();
+        const ingoingRefs = subflow.in;
+        const remainingIn = [];
         for (const ingoing of ingoingRefs) {
-            for (const { nodeId } of exitPoints) {
-                const node = subgraph.getVertex(nodeId, true);
-                const env = (0, environment_1.initializeCleanEnvironments)();
-                env.current.memory = node === undefined ? outEnvironment.current.memory : (node.environment?.current.memory ?? outEnvironment.current.memory);
-                const resolved = ingoing.name ? (0, resolve_by_name_1.resolveByName)(ingoing.name, env) : undefined;
-                if (resolved === undefined) {
-                    remainingIn.add(ingoing);
-                    continue;
-                }
-                logger_1.dataflowLogger.trace(`Found ${resolved.length} references to open ref ${id} in closure of function definition ${name.info.id}`);
-                for (const ref of resolved) {
-                    subgraph.addEdge(ingoing, ref, { type: 1 /* EdgeType.Reads */ });
-                }
+            const resolved = ingoing.name ? (0, resolve_by_name_1.resolveByName)(ingoing.name, outEnvironment) : undefined;
+            if (resolved === undefined) {
+                remainingIn.push(ingoing);
+                continue;
+            }
+            (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Found ${resolved.length} references to open ref ${id} in closure of function definition ${name.info.id}`);
+            for (const ref of resolved) {
+                subgraph.addEdge(ingoing, ref, { type: 1 /* EdgeType.Reads */ });
             }
         }
-        logger_1.dataflowLogger.trace(`Keeping ${remainingIn.size} (unique) references to open ref ${id} in closure of function definition ${name.info.id}`);
-        info.subflow.in = [...remainingIn];
+        (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Keeping ${remainingIn.length} references to open ref ${id} in closure of function definition ${name.info.id}`);
+        subflow.in = remainingIn;
     }
 }
 function prepareFunctionEnvironment(data) {
@@ -127,11 +123,11 @@ function prepareFunctionEnvironment(data) {
 /**
  * Within something like `f <- function(a=b, m=3) { b <- 1; a; b <- 5; a + 1 }`
  * `a` will be defined by `b` and `b`will be a promise object bound by the first definition of b it can find.
- * This means, that this function returns `2` due to the first `b <- 1` definition.
+ * This means that this function returns `2` due to the first `b <- 1` definition.
  * If the code is `f <- function(a=b, m=3) { if(m > 3) { b <- 1; }; a; b <- 5; a + 1 }`, we need a link to `b <- 1` and `b <- 6`
  * as `b` can be defined by either one of them.
  * <p>
- * <b>Currently we may be unable to narrow down every definition within the body as we have not implemented ways to track what covers a first definitions</b>
+ * <b>Currently we may be unable to narrow down every definition within the body as we have not implemented ways to track what covers the first definitions precisely</b>
  */
 function findPromiseLinkagesForParameters(parameters, readInParameters, parameterEnvs, body) {
     // first, we try to bind again within parameters - if we have it, fine

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/internal/process/process-value.js

@@ -11,7 +11,6 @@ function processValue(value, data) {
         graph: new graph_1.DataflowGraph(data.completeAst.idMap).addVertex({
             tag: "value" /* VertexType.Value */,
             id: value.info.id,
-            value: value.lexeme,
             controlDependencies: data.controlDependencies
         }),
         exitPoints: [{ nodeId: value.info.id, type: 0 /* ExitPointType.Default */, controlDependencies: data.controlDependencies }],

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.1",
+  "version": "2.0.3",
   "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",
@@ -226,6 +228,7 @@
     "n-readlines": "^1.0.1",
     "n3": "^1.17.2",
     "object-hash": "^3.0.0",
+    "object-sizeof": "^2.6.4",
     "rotating-file-stream": "^3.1.1",
     "semver": "^7.5.4",
     "tar": "^7.1.0",

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

@@ -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.

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