@eagleoutice/flowr 2.9.9 → 2.9.10

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

@@ -14,6 +14,7 @@ const general_1 = require("../../../../../eval/values/general");
 const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
 const reference_to_maybe_1 = require("../../../../../environments/reference-to-maybe");
 const built_in_1 = require("../../../../../environments/built-in");
+const append_1 = require("../../../../../environments/append");
 /**
  * Process a while loop like `while(cond) { ... }`.
  */
@@ -27,6 +28,8 @@ function processWhileLoop(name, args, rootId, data) {
         logger_1.dataflowLogger.warn(`While-Loop ${identifier_1.Identifier.toString(name.content)} has empty arguments in ${JSON.stringify(args)}, skipping`);
         return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'default' }).information;
     }
+    const nameId = name.info.id;
+    const origEnv = data.environment;
     // we should defer this to the abstract interpretation
     const values = (0, alias_tracking_1.resolveIdToValue)(unpackedArgs[0]?.info.id, { environment: data.environment, idMap: data.completeAst.idMap, resolve: data.ctx.config.solver.variables, ctx: data.ctx });
     const conditionIsAlwaysFalse = (0, general_1.valueSetGuard)(values)?.elements.every(d => d.type === 'logical' && d.value === false) ?? false;
@@ -41,49 +44,49 @@ function processWhileLoop(name, args, rootId, data) {
         rootId,
         data,
         markAsNSE: [1],
-        patchData: (d, i) => {
-            if (i === 1) {
-                return { ...d, cds: [...d.cds ?? [], { id: name.info.id, when: true }] };
-            }
-            return d;
-        }, origin: built_in_1.BuiltInProcName.WhileLoop
+        origin: built_in_1.BuiltInProcName.WhileLoop
     });
     const [condition, body] = processedArguments;
     // If the condition is always false, we don't include the body
     if (condition !== undefined && conditionIsAlwaysFalse) {
-        information.graph.addEdge(name.info.id, condition.entryPoint, edge_1.EdgeType.Reads);
+        information.graph.addEdge(nameId, condition.entryPoint, edge_1.EdgeType.Reads);
         return {
             unknownReferences: [],
-            in: [{ nodeId: name.info.id, name: name.lexeme, cds: data.cds, type: identifier_1.ReferenceType.Function }],
+            in: [{ nodeId: nameId, name: name.lexeme, cds: data.cds, type: identifier_1.ReferenceType.Function }],
             out: condition.out,
-            entryPoint: name.info.id,
+            entryPoint: nameId,
             exitPoints: [],
             graph: information.graph,
             environment: information.environment,
             hooks: condition.hooks
         };
     }
+    const conditionIsAlwaysTrue = (0, general_1.valueSetGuard)(values)?.elements.every(d => d.type === 'logical' && d.value === true) ?? false;
     (0, assert_1.guard)(condition !== undefined && body !== undefined, () => `While-Loop ${identifier_1.Identifier.toString(name.content)} has no condition or body, impossible!`);
     const originalDependency = data.cds;
     if ((0, info_1.alwaysExits)(condition)) {
         logger_1.dataflowLogger.warn(`While-Loop ${rootId} forces exit in condition, skipping rest`);
-        information.graph.addEdge(name.info.id, condition.entryPoint, edge_1.EdgeType.Reads);
+        information.graph.addEdge(nameId, condition.entryPoint, edge_1.EdgeType.Reads);
         return condition;
     }
-    const cdTrue = [{ id: name.info.id, when: true }];
-    const remainingInputs = (0, linker_1.linkInputs)((0, reference_to_maybe_1.makeAllMaybe)(body.unknownReferences, information.graph, information.environment, false, cdTrue).concat((0, reference_to_maybe_1.makeAllMaybe)(body.in, information.graph, information.environment, false, cdTrue)), information.environment, condition.in.concat(condition.unknownReferences), information.graph, true);
-    (0, linker_1.linkCircularRedefinitionsWithinALoop)(information.graph, (0, linker_1.produceNameSharedIdMap)((0, linker_1.findNonLocalReads)(information.graph, condition.in)), body.out);
-    (0, linker_1.reapplyLoopExitPoints)(body.exitPoints, body.in.concat(body.out, body.unknownReferences));
+    const cdTrue = [{ id: nameId, when: true }];
+    const bodyRead = body.in.concat(body.unknownReferences);
+    (0, reference_to_maybe_1.applyCdsToAllInGraphButConstants)(body.graph, bodyRead, cdTrue);
+    const remainingInputs = (0, linker_1.linkInputs)(bodyRead, information.environment, condition.in.concat(condition.unknownReferences), information.graph, true);
+    (0, reference_to_maybe_1.applyCdToReferences)(body.out, cdTrue);
+    (0, linker_1.linkCircularRedefinitionsWithinALoop)(information.graph, (0, linker_1.produceNameSharedIdMap)((0, linker_1.findNonLocalReads)(information.graph, new Set(condition.in.map(i => i.nodeId)))), body.out);
+    (0, linker_1.reapplyLoopExitPoints)(body.exitPoints, body.in.concat(body.out, body.unknownReferences), information.graph);
     // as the while-loop always evaluates its condition
-    information.graph.addEdge(name.info.id, condition.entryPoint, edge_1.EdgeType.Reads);
+    information.graph.addEdge(nameId, condition.entryPoint, edge_1.EdgeType.Reads);
     return {
         unknownReferences: [],
-        in: [{ nodeId: name.info.id, name: name.lexeme, cds: originalDependency, type: identifier_1.ReferenceType.Function }, ...remainingInputs],
-        out: condition.out.concat((0, reference_to_maybe_1.makeAllMaybe)(body.out, information.graph, information.environment, true, cdTrue)),
-        entryPoint: name.info.id,
+        in: [{ nodeId: nameId, name: name.lexeme, cds: originalDependency, type: identifier_1.ReferenceType.Function }, ...remainingInputs],
+        out: condition.out.concat(body.out),
+        entryPoint: nameId,
         exitPoints: (0, info_1.filterOutLoopExitPoints)(body.exitPoints),
         graph: information.graph,
-        environment: information.environment,
+        // as we do not know whether the loop executes at all, we have to merge the environments of the condition and the body, as both may be relevant
+        environment: conditionIsAlwaysTrue ? information.environment : (0, append_1.appendEnvironment)(origEnv, information.environment),
         hooks: condition.hooks.concat(body.hooks)
     };
 }

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

@@ -9,7 +9,6 @@ const graph_1 = require("../../../../graph/graph");
 const edge_1 = require("../../../../graph/edge");
 const logger_1 = require("../../../../logger");
 const vertex_1 = require("../../../../graph/vertex");
-const log_1 = require("../../../../../util/log");
 const unknown_side_effect_1 = require("../../../../graph/unknown-side-effect");
 const built_in_1 = require("../../../../environments/built-in");
 /**
@@ -36,7 +35,6 @@ function processKnownFunctionCall({ name, args, rootId, data, reverseOrder = fal
     const functionName = (0, processor_1.processDataflowFor)(name, data);
     const finalGraph = new graph_1.DataflowGraph(data.completeAst.idMap);
     const functionCallName = name.content;
-    (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Processing known function call ${identifier_1.Identifier.toString(functionCallName)} with ${args.length} arguments`);
     const processArgs = reverseOrder ? args.toReversed() : args;
     const { finalEnv, callArgs, remainingReadInArgs, processedArguments } = (0, common_1.processAllArguments)({ functionName, args: processArgs, data, finalGraph, functionRootId: rootId, patchData, forceArgs });
     if (markAsNSE) {

package/documentation/wiki-absint.js

@@ -17,7 +17,7 @@ class IntervalInferenceVisitor extends absint_visitor_1.AbstractInterpretationVi
     onNumberConstant({ vertex, node }) {
         super.onNumberConstant({ vertex, node });
         const interval = new interval_domain_1.IntervalDomain([node.content.num, node.content.num]);
-        this.currentState.set(node.info.id, interval);
+        this.updateState(node.info.id, interval);
     }
     onFunctionCall({ call }) {
         super.onFunctionCall({ call });
@@ -31,9 +31,9 @@ class IntervalInferenceVisitor extends absint_visitor_1.AbstractInterpretationVi
             // We map the numerical operation to the resulting interval after applying the abstract semantics of the operation
             switch (identifier_1.Identifier.getName(call.name)) {
                 case '+':
-                    return this.currentState.set(call.id, left.add(right));
+                    return this.updateState(call.id, left.add(right));
                 case '-':
-                    return this.currentState.set(call.id, left.subtract(right));
+                    return this.updateState(call.id, left.subtract(right));
             }
         }
     }
@@ -51,8 +51,7 @@ async function inferIntervals() {
     const dfg = (await analyzer.dataflow()).graph;
     const cfg = await analyzer.controlflow(undefined, cfg_kind_1.CfgKind.NoFunctionDefs);
     const ctx = analyzer.inspectContext();
-    const domain = new state_abstract_domain_1.StateAbstractDomain(new Map());
-    const inference = new IntervalInferenceVisitor({ controlFlow: cfg, dfg: dfg, normalizedAst: ast, ctx: ctx, domain: domain });
+    const inference = new IntervalInferenceVisitor({ controlFlow: cfg, dfg: dfg, normalizedAst: ast, ctx: ctx });
     inference.start();
     const result = inference.getEndState();
     return result.value.entries().toArray()
@@ -128,15 +127,15 @@ For example, if we want to perform a (very basic) interval analysis using abstra
 
 ${ctx.code(IntervalInferenceVisitor)}
 
-The interval inference visitor first overrides the ${ctx.link(`${semantic_cfg_guided_visitor_1.SemanticCfgGuidedVisitor.name}:::onNumberConstant`)} function to infer intervals for visited control flow vertices that represent numeric constants. For numeric constants, the resulting interval consists just of the number value of the constant. We then update the current abstract state of the visitor by setting the inferred abstract value of the currently visited control flow vertex to the new interval.
+The interval inference visitor first overrides the ${ctx.link(`${semantic_cfg_guided_visitor_1.SemanticCfgGuidedVisitor.name}:::onNumberConstant`)} function to infer intervals for visited control flow vertices that represent numeric constants. For numeric constants, the resulting interval consists just of the number value of the constant. We then update the current abstract state of the visitor via ${ctx.linkM(absint_visitor_1.AbstractInterpretationVisitor, 'updateState', { hideClass: true })} by setting the inferred abstract value of the currently visited control flow vertex to the new interval.
 
-In this simple example, we only want to support the addition and subtraction of numeric values. Therefore, we override the ${ctx.link(`${absint_visitor_1.AbstractInterpretationVisitor.name}:::onFunctionCall`)} function to apply the abstract semantics of additions and subtraction with resprect to the interval domain. For the addition and subtraction, we are only interested in function calls with exactly two non-empty arguments. We first resolve the currently inferred abstract value for the left and right operand of the function call. If we have no inferred value for one of the operands, this function call might not be a numeric function call and we ignore it. Otherwise, we check whether the function call represents an addition or subtraction and apply the abstract semantics of the operation to the left and right operand. We then again update the current abstract state of the visitor by setting the inferred abstract value of the currently visited function call vertex to the abstract value resulting from applying the abstract semantics of the operation to the operands.
+In this simple example, we only want to support the addition and subtraction of numeric values. Therefore, we override the ${ctx.link(`${absint_visitor_1.AbstractInterpretationVisitor.name}:::onFunctionCall`)} function to apply the abstract semantics of additions and subtraction with resprect to the interval domain. For the addition and subtraction, we are only interested in function calls with exactly two non-empty arguments. We first resolve the currently inferred abstract value for the left and right operand of the function call. If we have no inferred value for one of the operands, this function call might not be a numeric function call and we ignore it. Otherwise, we check whether the function call represents an addition or subtraction and apply the abstract semantics of the operation to the left and right operand. We then again update the current abstract state of the visitor via ${ctx.linkM(absint_visitor_1.AbstractInterpretationVisitor, 'updateState', { hideClass: true })} by setting the inferred abstract value of the currently visited function call vertex to the abstract value resulting from applying the abstract semantics of the operation to the operands.
 
 If we now want to run the interval inference, we can write the following code:
 
 ${ctx.code(inferIntervals, { dropLinesStart: 1, dropLinesEnd: 5 })}
 
-We first need a ${ctx.linkPage('wiki/Analyzer', 'flowR analyzer')} (in this case, using the ${ctx.linkPage('wiki/Engines', 'tree-sitter engine')}). In this example, we want to analyze a small example code that assigns \`42\` to the variable \`x\`, randomly assigns \`6\` or \`12\` to the variable \`y\`, and assignes the sum of \`x\` and \`y\` to the variable \`z\`. For the abstract interpretation visitor, we need to retrieve the ${ctx.linkPage('wiki/Normalized AST', 'normalized AST')}, ${ctx.linkPage('wiki/Dataflow Graph', 'dataflow graph')}, ${ctx.linkPage('wiki/Control Flow Graph', 'control flow graph')}, and context of the flowR anaylzer. Additionally, we need to provide a state abstract domain for the visitor -- in this case, a state abstract domain for the interval domain. We then construct a new ${ctx.link(IntervalInferenceVisitor)} using the control flow graph, dataflow graph, normalized AST, analyzer context, and state abstract domain, and start the visitor using ${ctx.linkM(absint_visitor_1.AbstractInterpretationVisitor, 'start', { hideClass: true })}. After the visitor is finished, we retrieve the inferred abstract state at the end of the program using ${ctx.linkM(absint_visitor_1.AbstractInterpretationVisitor, 'getEndState', { hideClass: true })}.
+We first need a ${ctx.linkPage('wiki/Analyzer', 'flowR analyzer')} (in this case, using the ${ctx.linkPage('wiki/Engines', 'tree-sitter engine')}). In this example, we want to analyze a small example code that assigns \`42\` to the variable \`x\`, randomly assigns \`6\` or \`12\` to the variable \`y\`, and assignes the sum of \`x\` and \`y\` to the variable \`z\`. For the abstract interpretation visitor, we need to retrieve the ${ctx.linkPage('wiki/Normalized AST', 'normalized AST')}, ${ctx.linkPage('wiki/Dataflow Graph', 'dataflow graph')}, ${ctx.linkPage('wiki/Control Flow Graph', 'control flow graph')}, and context of the flowR anaylzer. For performance reasons, we construct the control flow graph without simplification passes, data flow information, and function definitions. We then create a new ${ctx.link(IntervalInferenceVisitor)} using the control flow graph, dataflow graph, normalized AST, and analyzer context, and start the visitor using ${ctx.linkM(absint_visitor_1.AbstractInterpretationVisitor, 'start', { hideClass: true })}. After the visitor is finished, we retrieve the inferred abstract state at the end of the program using ${ctx.linkM(absint_visitor_1.AbstractInterpretationVisitor, 'getEndState', { hideClass: true })}.
 
 If we now print the inferred abstract state at the end of the program, we get the following output:
 

package/linter/rules/dead-code.js

@@ -22,7 +22,7 @@ exports.DEAD_CODE = {
                 .filter(element => {
                 meta.consideredNodes++;
                 const cfgInformation = (0, search_enrichers_1.enrichmentContent)(element, search_enrichers_1.Enrichment.CfgInformation);
-                return cfgInformation.isRoot && !cfgInformation.isReachable;
+                return element.node.info.role !== "el-g" /* RoleInParent.ExpressionListGrouping */ && !cfgInformation.isReachable;
             })
                 .map(element => ({
                 certainty: linter_format_1.LintingResultCertainty.Certain,

package/linter/rules/seeded-randomness.js

@@ -35,7 +35,7 @@ exports.SEEDED_RANDOMNESS = {
         { callName: getDefaultAssignments().flatMap(b => b.names).map(identifier_1.Identifier.getName), cascadeIf: () => cascade_action_1.CascadeAction.Continue }
     ]),
     processSearchResult: (elements, config, { dataflow, analyzer }) => {
-        const assignmentProducers = new Set(config.randomnessProducers.filter(p => p.type == 'assignment').map(p => p.name));
+        const assignmentProducers = new Set(config.randomnessProducers.filter(p => p.type === 'assignment').map(p => p.name));
         const assignmentArgIndexes = new Map(getDefaultAssignments().flatMap(a => a.names.map(n => ([identifier_1.Identifier.getName(n), a.config?.swapSourceAndTarget ? 1 : 0]))));
         const metadata = {
             consumerCalls: 0,

package/linter/rules/unused-definition.js

@@ -19,7 +19,7 @@ function getDefinitionArguments(def, dfg) {
 function buildQuickFix(variable, dfg, ast) {
     // first we check whether any of the 'Defined by' targets have any obligations - if so, we can not remove the definition
     // otherwise we can automatically remove the full definition!
-    if (variable.info.role === "accessed" /* RoleInParent.Accessed */ || variable.info.role === "for-var" /* RoleInParent.ForVariable */) {
+    if (variable.info.role === "acc" /* RoleInParent.Accessed */ || variable.info.role === "for-var" /* RoleInParent.ForVariable */) {
         // this is an access or a for variable, we can not remove it currently
         return undefined;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/flowr",
-  "version": "2.9.9",
+  "version": "2.9.10",
   "description": "Static Dataflow Analyzer and Program Slicer for the R Programming Language",
   "types": "dist/src/index.d.ts",
   "repository": {
@@ -199,7 +199,7 @@
   },
   "dependencies": {
     "@eagleoutice/tree-sitter-r": "^1.1.2",
-    "@jupyterlab/nbformat": "^4.5.0",
+    "@jupyterlab/nbformat": "^4.5.4",
     "@xmldom/xmldom": "^0.9.7",
     "clipboardy": "^4.0.0",
     "command-line-args": "^6.0.1",
@@ -209,17 +209,17 @@
     "gray-matter": "^4.0.3",
     "joi": "^18.0.1",
     "lz-string": "^1.5.0",
-    "n-readlines": "^1.0.1",
-    "n3": "^1.23.1",
+    "n-readlines": "^1.0.3",
+    "n3": "^1.26.0",
     "object-hash": "^3.0.0",
     "object-sizeof": "^2.6.5",
-    "rotating-file-stream": "^3.2.6",
+    "rotating-file-stream": "^3.2.8",
     "seedrandom": "^3.0.5",
-    "semver": "^7.7.1",
+    "semver": "^7.7.4",
     "tar": "^7.4.3",
     "tmp": "^0.2.3",
     "ts-essentials": "^10.1.1",
-    "tslog": "^4.9.3",
+    "tslog": "^4.10.2",
     "web-tree-sitter": "^0.24.7",
     "ws": "^8.18.0",
     "xpath-ts2": "^1.4.2"

package/project/plugins/file-plugins/files/flowr-description-file.d.ts

@@ -24,6 +24,10 @@ export declare class FlowrDescriptionFile extends FlowrFile<DeepReadonly<DCF>> {
      * @see {@link parseDCF} for details on the parsing logic.
      */
     protected loadContent(): DCF;
+    /**
+     * Creates a FlowrDescriptionFile from given DCF content, path and optional roles.
+     * This is useful if you already have the DCF content parsed and want to create a description file instance without re-parsing.
+     */
     static fromDCF(dcf: DCF, path: string, roles?: FileRole[]): FlowrDescriptionFile;
     /**
      * Description file lifter, this does not re-create if already a description file

package/project/plugins/file-plugins/files/flowr-description-file.js

@@ -34,6 +34,10 @@ class FlowrDescriptionFile extends flowr_file_1.FlowrFile {
     loadContent() {
         return parseDCF(this.wrapped);
     }
+    /**
+     * Creates a FlowrDescriptionFile from given DCF content, path and optional roles.
+     * This is useful if you already have the DCF content parsed and want to create a description file instance without re-parsing.
+     */
     static fromDCF(dcf, path, roles) {
         const file = new FlowrDescriptionFile(new flowr_file_1.FlowrTextFile(path, roles));
         file.setContent(dcf);

package/queries/catalog/call-context-query/call-context-query-executor.js

@@ -173,7 +173,7 @@ function doesFilepathMatch(file, filter) {
 function isParameterDefaultValue(nodeId, ast) {
     let node = ast.idMap.get(nodeId);
     while (node !== undefined) {
-        if (node.info.role === "param-value" /* RoleInParent.ParameterDefaultValue */) {
+        if (node.info.role === "param-v" /* RoleInParent.ParameterDefaultValue */) {
             return true;
         }
         const nip = node.info.parent;

package/queries/catalog/df-shape-query/df-shape-query-format.d.ts

@@ -1,6 +1,6 @@
 import Joi from 'joi';
 import type { DataFrameDomain } from '../../../abstract-interpretation/data-frame/dataframe-domain';
-import { StateAbstractDomain } from '../../../abstract-interpretation/domains/state-abstract-domain';
+import type { StateAbstractDomain } from '../../../abstract-interpretation/domains/state-abstract-domain';
 import type { ReplOutput } from '../../../cli/repl/commands/repl-main';
 import type { FlowrConfigOptions } from '../../../config';
 import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';

package/queries/catalog/df-shape-query/df-shape-query-format.js

@@ -5,11 +5,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DfShapeQueryDefinition = void 0;
 const joi_1 = __importDefault(require("joi"));
-const state_abstract_domain_1 = require("../../../abstract-interpretation/domains/state-abstract-domain");
 const slice_query_parser_1 = require("../../../cli/repl/parser/slice-query-parser");
 const ansi_1 = require("../../../util/text/ansi");
 const time_1 = require("../../../util/text/time");
 const df_shape_query_executor_1 = require("./df-shape-query-executor");
+const abstract_domain_1 = require("../../../abstract-interpretation/domains/abstract-domain");
 function dfShapeQueryLineParser(_output, line, _config) {
     const criterion = (0, slice_query_parser_1.sliceCriterionParser)(line[0]);
     return {
@@ -24,7 +24,7 @@ exports.DfShapeQueryDefinition = {
     executor: df_shape_query_executor_1.executeDfShapeQuery,
     asciiSummarizer: (formatter, _analyzer, queryResults, result) => {
         const out = queryResults;
-        const domains = out.domains instanceof state_abstract_domain_1.StateAbstractDomain ? out.domains.value : out.domains;
+        const domains = out.domains instanceof abstract_domain_1.AbstractDomain ? out.domains.value : out.domains;
         result.push(`Query: ${(0, ansi_1.bold)('df-shape', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
         result.push(...domains.entries().take(20).map(([key, domain]) => {
             return `   ╰ ${key}: ${domain?.toString()}`;
@@ -36,7 +36,7 @@ exports.DfShapeQueryDefinition = {
     },
     jsonFormatter: (queryResults) => {
         const { domains, ...out } = queryResults;
-        const state = domains instanceof state_abstract_domain_1.StateAbstractDomain ? domains.value : domains;
+        const state = domains instanceof abstract_domain_1.AbstractDomain ? domains.value : domains;
         const json = Object.fromEntries(state.entries().map(([key, domain]) => [key, domain?.toJson() ?? null]));
         const result = { domains: json, ...out };
         return result;

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

@@ -173,12 +173,12 @@ function createFoldForBinaryOp(info) {
         rhsInfo.parent = id;
         rhsInfo.index = 1;
         if (data.type === type_1.RType.Pipe) {
-            lhsInfo.role = "pipe-lhs" /* RoleInParent.PipeLhs */;
-            rhsInfo.role = "pipe-rhs" /* RoleInParent.PipeRhs */;
+            lhsInfo.role = "pipe-l" /* RoleInParent.PipeLhs */;
+            rhsInfo.role = "pipe-r" /* RoleInParent.PipeRhs */;
         }
         else {
-            lhsInfo.role = "binop-lhs" /* RoleInParent.BinaryOperationLhs */;
-            rhsInfo.role = "binop-rhs" /* RoleInParent.BinaryOperationRhs */;
+            lhsInfo.role = "bin-l" /* RoleInParent.BinaryOperationLhs */;
+            rhsInfo.role = "bin-r" /* RoleInParent.BinaryOperationRhs */;
         }
         decorated.info.file = info.file;
         return decorated;
@@ -203,7 +203,7 @@ function createFoldForAccess(info) {
         info.idMap.set(id, decorated);
         const accessedInfo = accessed.info;
         accessedInfo.parent = id;
-        accessedInfo.role = "accessed" /* RoleInParent.Accessed */;
+        accessedInfo.role = "acc" /* RoleInParent.Accessed */;
         if (typeof access !== 'string') {
             let idx = 0; // the first oe will be skipped in the first iter
             for (const acc of access) {
@@ -212,7 +212,7 @@ function createFoldForAccess(info) {
                     const curInfo = acc.info;
                     curInfo.parent = id;
                     curInfo.index = idx;
-                    curInfo.role = "index-acc" /* RoleInParent.IndexAccess */;
+                    curInfo.role = "idx-acc" /* RoleInParent.IndexAccess */;
                 }
             }
         }
@@ -235,7 +235,7 @@ function createFoldForForLoop(info) {
         const bodyInfo = body.info;
         bodyInfo.parent = id;
         bodyInfo.index = 2;
-        bodyInfo.role = "for-body" /* RoleInParent.ForBody */;
+        bodyInfo.role = "for-b" /* RoleInParent.ForBody */;
         decorated.info.file = info.file;
         return decorated;
     };
@@ -247,7 +247,7 @@ function createFoldForRepeatLoop(info) {
         info.idMap.set(id, decorated);
         const bodyInfo = body.info;
         bodyInfo.parent = id;
-        bodyInfo.role = "repeat-body" /* RoleInParent.RepeatBody */;
+        bodyInfo.role = "repeat-b" /* RoleInParent.RepeatBody */;
         decorated.info.file = info.file;
         return decorated;
     };
@@ -259,11 +259,11 @@ function createFoldForWhileLoop(info) {
         info.idMap.set(id, decorated);
         const condInfo = condition.info;
         condInfo.parent = id;
-        condInfo.role = "while-cond" /* RoleInParent.WhileCondition */;
+        condInfo.role = "while-c" /* RoleInParent.WhileCondition */;
         const bodyInfo = body.info;
         bodyInfo.parent = id;
         bodyInfo.index = 1;
-        bodyInfo.role = "while-body" /* RoleInParent.WhileBody */;
+        bodyInfo.role = "while-b" /* RoleInParent.WhileBody */;
         decorated.info.file = info.file;
         return decorated;
     };
@@ -275,7 +275,7 @@ function createFoldForIfThenElse(info) {
         info.idMap.set(id, decorated);
         const condInfo = condition.info;
         condInfo.parent = id;
-        condInfo.role = "if-cond" /* RoleInParent.IfCondition */;
+        condInfo.role = "if-c" /* RoleInParent.IfCondition */;
         const thenInfo = then.info;
         thenInfo.parent = id;
         thenInfo.index = 1;
@@ -300,7 +300,13 @@ function createFoldForExprList(info) {
             const childInfo = child.info;
             childInfo.parent = id;
             childInfo.index = i++;
-            childInfo.role = "expr-list-child" /* RoleInParent.ExpressionListChild */;
+            childInfo.role = "el-c" /* RoleInParent.ExpressionListChild */;
+        }
+        // assign role for grouping
+        if (grouping) {
+            const [open, close] = grouping;
+            open.info.role = "el-g" /* RoleInParent.ExpressionListGrouping */;
+            close.info.role = "el-g" /* RoleInParent.ExpressionListGrouping */;
         }
         decorated.info.file = info.file;
         return decorated;
@@ -349,7 +355,7 @@ function createFoldForFunctionDefinition(info) {
         const bodyInfo = body.info;
         bodyInfo.parent = id;
         bodyInfo.index = idx;
-        bodyInfo.role = "fun-body" /* RoleInParent.FunctionDefinitionBody */;
+        bodyInfo.role = "fun-b" /* RoleInParent.FunctionDefinitionBody */;
         decorated.info.file = info.file;
         return decorated;
     };
@@ -361,12 +367,12 @@ function createFoldForFunctionParameter(info) {
         info.idMap.set(id, decorated);
         const nameInfo = name.info;
         nameInfo.parent = id;
-        nameInfo.role = "param-name" /* RoleInParent.ParameterName */;
+        nameInfo.role = "param-n" /* RoleInParent.ParameterName */;
         if (defaultValue) {
             const defaultInfo = defaultValue.info;
             defaultInfo.parent = id;
             defaultInfo.index = 1;
-            defaultInfo.role = "param-value" /* RoleInParent.ParameterDefaultValue */;
+            defaultInfo.role = "param-v" /* RoleInParent.ParameterDefaultValue */;
         }
         decorated.info.file = info.file;
         return decorated;
@@ -381,14 +387,14 @@ function createFoldForFunctionArgument(info) {
         if (name) {
             const nameInfo = name.info;
             nameInfo.parent = id;
-            nameInfo.role = "arg-name" /* RoleInParent.ArgumentName */;
+            nameInfo.role = "arg-n" /* RoleInParent.ArgumentName */;
             idx++; // adaptive, 0 for the value if there is no name!
         }
         if (value) {
             const valueInfo = value.info;
             valueInfo.parent = id;
             valueInfo.index = idx;
-            valueInfo.role = "arg-value" /* RoleInParent.ArgumentValue */;
+            valueInfo.role = "arg-v" /* RoleInParent.ArgumentValue */;
         }
         decorated.info.file = info.file;
         return decorated;

package/r-bridge/lang-4.x/ast/model/processing/role.d.ts

@@ -8,31 +8,32 @@ import type { AstIdMap, RNodeWithParent } from './decorate';
 export declare const enum RoleInParent {
     /** has no parent */
     Root = "root",
-    IfCondition = "if-cond",
+    IfCondition = "if-c",
     IfThen = "if-then",
     IfOtherwise = "if-other",
-    WhileCondition = "while-cond",
-    WhileBody = "while-body",
-    RepeatBody = "repeat-body",
+    WhileCondition = "while-c",
+    WhileBody = "while-b",
+    RepeatBody = "repeat-b",
     ForVariable = "for-var",
     ForVector = "for-vec",
-    ForBody = "for-body",
+    ForBody = "for-b",
     FunctionCallName = "call-name",
     FunctionCallArgument = "call-arg",
-    FunctionDefinitionBody = "fun-body",
+    FunctionDefinitionBody = "fun-b",
     FunctionDefinitionParameter = "param",
-    ExpressionListChild = "expr-list-child",
-    BinaryOperationLhs = "binop-lhs",
-    BinaryOperationRhs = "binop-rhs",
-    PipeLhs = "pipe-lhs",
-    PipeRhs = "pipe-rhs",
+    ExpressionListChild = "el-c",
+    ExpressionListGrouping = "el-g",
+    BinaryOperationLhs = "bin-l",
+    BinaryOperationRhs = "bin-r",
+    PipeLhs = "pipe-l",
+    PipeRhs = "pipe-r",
     UnaryOperand = "unary-op",
-    ParameterName = "param-name",
-    ParameterDefaultValue = "param-value",
-    ArgumentName = "arg-name",
-    ArgumentValue = "arg-value",
-    Accessed = "accessed",
-    IndexAccess = "index-acc"
+    ParameterName = "param-n",
+    ParameterDefaultValue = "param-v",
+    ArgumentName = "arg-n",
+    ArgumentValue = "arg-v",
+    Accessed = "acc",
+    IndexAccess = "idx-acc"
 }
 /**
  * Returns the roles of the parents of the given node, starting with the parent-role of the node itself.

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

@@ -260,7 +260,8 @@ function convertTreeNode(node) {
                     ...defaultInfo
                 };
             case tree_sitter_types_1.TreeSitterType.IfStatement: {
-                const [ifNode, /* ( */ , condition, /* ) */ , then, /* else */ , ...otherwise] = nonErrorChildren(node);
+                const [comments, children] = splitComments(nonErrorChildren(node));
+                const [ifNode, /* ( */ , condition, /* ) */ , then, /* else */ , ...otherwise] = children;
                 const filteredOtherwise = otherwise.filter(n => n.type !== tree_sitter_types_1.TreeSitterType.ElseStatement);
                 return {
                     type: type_1.RType.IfThenElse,
@@ -269,11 +270,14 @@ function convertTreeNode(node) {
                     otherwise: filteredOtherwise.length > 0 ? (0, normalize_meta_1.ensureExpressionList)(convertTreeNode(filteredOtherwise[0])) : undefined,
                     location: makeSourceRange(ifNode),
                     lexeme: ifNode.text,
-                    ...defaultInfo
+                    info: {
+                        ...defaultInfo.info,
+                        adToks: comments.map(c => c[1]),
+                    }
                 };
             }
             case tree_sitter_types_1.TreeSitterType.ForStatement: {
-                const children = nonErrorChildren(node);
+                const [comments, children] = splitComments(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 (
@@ -300,31 +304,38 @@ function convertTreeNode(node) {
                     lexeme: forNode.text,
                     info: {
                         fullRange: range,
-                        adToks: variableComments.concat(sequenceComments).map(c => c[1]),
+                        adToks: variableComments.concat(comments, sequenceComments).map(c => c[1]),
                         fullLexeme: node.text,
                         tsId: node.id
                     }
                 };
             }
             case tree_sitter_types_1.TreeSitterType.WhileStatement: {
-                const [whileNode, /* ( */ , condition, /* ) */ , body] = nonErrorChildren(node);
+                const [comments, children] = splitComments(nonErrorChildren(node));
+                const [whileNode, /* ( */ , condition, /* ) */ , body] = children;
                 return {
                     type: type_1.RType.WhileLoop,
                     condition: convertTreeNode(condition),
                     body: (0, normalize_meta_1.ensureExpressionList)(convertTreeNode(body)),
                     location: makeSourceRange(whileNode),
                     lexeme: whileNode.text,
-                    ...defaultInfo
+                    info: {
+                        ...defaultInfo.info,
+                        adToks: comments.map(c => c[1]),
+                    }
                 };
             }
             case tree_sitter_types_1.TreeSitterType.RepeatStatement: {
-                const [repeatNode, body] = nonErrorChildren(node);
+                const [comments, [repeatNode, body]] = splitComments(nonErrorChildren(node));
                 return {
                     type: type_1.RType.RepeatLoop,
                     body: (0, normalize_meta_1.ensureExpressionList)(convertTreeNode(body)),
                     location: makeSourceRange(repeatNode),
                     lexeme: repeatNode.text,
-                    ...defaultInfo
+                    info: {
+                        ...defaultInfo.info,
+                        adToks: comments.map(c => c[1]),
+                    }
                 };
             }
             case tree_sitter_types_1.TreeSitterType.Call: {
@@ -449,7 +460,8 @@ function convertTreeNode(node) {
                 const [func, content] = nonErrorChildren(node);
                 // bracket is now [ or [[ and argsClosing is x] or x]]
                 const [bracket, ...argsClosing] = nonErrorChildren(content);
-                const args = (0, arrays_1.splitArrayOn)(argsClosing.slice(0, -1), x => x.type === 'comma');
+                const [argsComments, argsNoComments] = splitComments(argsClosing.slice(0, -1));
+                const args = (0, arrays_1.splitArrayOn)(argsNoComments, x => x.type === 'comma');
                 return {
                     type: type_1.RType.Access,
                     operator: bracket.text,
@@ -457,7 +469,10 @@ function convertTreeNode(node) {
                     access: args.map(n => n.length === 0 ? r_function_call_1.EmptyArgument : convertTreeNode(n[0])),
                     location: makeSourceRange(bracket),
                     lexeme: bracket.text,
-                    ...defaultInfo
+                    info: {
+                        ...defaultInfo.info,
+                        adToks: argsComments.map(c => c[1]),
+                    }
                 };
             }
             case tree_sitter_types_1.TreeSitterType.ExtractOperator: {
@@ -523,7 +538,7 @@ function convertTreeNode(node) {
                 };
             }
             case tree_sitter_types_1.TreeSitterType.Argument: {
-                const children = nonErrorChildren(node);
+                const [commentChildren, children] = splitComments(nonErrorChildren(node));
                 if (children.length === 1) {
                     const [arg] = children;
                     return {
@@ -532,7 +547,10 @@ function convertTreeNode(node) {
                         value: convertTreeNode(arg),
                         location: range,
                         lexeme: node.text,
-                        ...defaultInfo
+                        info: {
+                            ...defaultInfo.info,
+                            adToks: commentChildren.map(c => c[1]),
+                        }
                     };
                 }
                 else {
@@ -558,7 +576,7 @@ function convertTreeNode(node) {
                         lexeme: nameNode.text,
                         info: {
                             fullRange: nameRange,
-                            adToks: [],
+                            adToks: commentChildren.map(c => c[1]),
                             fullLexeme: nameNode.text,
                             tsId: nameNode.id
                         }

package/statistics/features/supported/data-access/data-access.js

@@ -54,11 +54,11 @@ function visitAccess(info, input) {
         let acc = false;
         let idxAcc = false;
         for (const role of roles) {
-            if (role === "accessed" /* RoleInParent.Accessed */) {
+            if (role === "acc" /* RoleInParent.Accessed */) {
                 acc = true;
                 break; // we only account for the first one
             }
-            else if (role === "index-acc" /* RoleInParent.IndexAccess */) {
+            else if (role === "idx-acc" /* RoleInParent.IndexAccess */) {
                 idxAcc = true;
                 break;
             }