@eagleoutice/flowr 2.9.5 → 2.9.7

package/queries/catalog/dependencies-query/dependencies-query-executor.js

@@ -4,26 +4,39 @@ exports.executeDependenciesQuery = executeDependenciesQuery;
 const query_1 = require("../../query");
 const dependencies_query_format_1 = require("./dependencies-query-format");
 const vertex_1 = require("../../../dataflow/graph/vertex");
-const log_1 = require("../../../util/log");
 const type_1 = require("../../../r-bridge/lang-4.x/ast/model/type");
 const objects_1 = require("../../../util/objects");
 const function_info_1 = require("./function-info/function-info");
 const identify_link_to_last_call_relation_1 = require("../call-context-query/identify-link-to-last-call-relation");
 const resolve_argument_1 = require("../../../dataflow/eval/resolve/resolve-argument");
 const assert_1 = require("../../../util/assert");
+const log_1 = require("../../../util/log");
 /**
  * Executes a dependencies query.
  */
 async function executeDependenciesQuery({ analyzer, }, queries) {
+    let query = queries[0];
     if (queries.length !== 1) {
-        log_1.log.warn('Dependencies query expects only up to one query, but got ', queries.length, 'only using the first query');
+        // merge
+        for (let i = 1; i < queries.length; i++) {
+            const q = queries[i];
+            query = {
+                ...query,
+                enabledCategories: query.enabledCategories === undefined && q.enabledCategories === undefined ? undefined : [...(query.enabledCategories ?? []), ...(q.enabledCategories ?? [])],
+                ignoreDefaultFunctions: query.ignoreDefaultFunctions || q.ignoreDefaultFunctions,
+                additionalCategories: {
+                    ...query.additionalCategories,
+                    ...q.additionalCategories
+                }
+            };
+        }
+        log_1.log.info('Merged multiple dependencies queries into one:', query);
     }
     const data = { analyzer };
     const normalize = await analyzer.normalize();
     const dataflow = await analyzer.dataflow();
     const config = analyzer.flowrConfig;
     const now = Date.now();
-    const [query] = queries;
     const ignoreDefault = query.ignoreDefaultFunctions ?? false;
     const functions = new Map(Object.entries(dependencies_query_format_1.DefaultDependencyCategories).map(([c, v]) => {
         return [c, getFunctionsToCheck(query[`${c}Functions`], c, query.enabledCategories, ignoreDefault, v.functions)];
@@ -35,12 +48,12 @@ async function executeDependenciesQuery({ analyzer, }, queries) {
         }
     }
     const queryResults = functions.values().toArray().flat().length === 0 ? { kinds: {}, '.meta': { timing: 0 } } :
-        await (0, query_1.executeQueriesOfSameType)(data, functions.entries().map(([c, f]) => makeCallContextQuery(f, c)).toArray().flat());
+        await (0, query_1.executeQueriesOfSameType)(data, functions.entries().flatMap(makeCallContextQuery).toArray());
     const g = (0, dependencies_query_format_1.getAllCategories)(queries);
+    const enabled = query.enabledCategories;
     const results = Object.fromEntries(await Promise.all(functions.entries().map(async ([c, f]) => {
         const results = getResults(queries, { dataflow, config, normalize }, queryResults, c, f, data);
         // only default categories allow additional analyses, so we null-coalesce here!
-        const enabled = query.enabledCategories;
         if (enabled === undefined || (enabled?.length > 0 && enabled.includes(c))) {
             await g[c]?.additionalAnalysis?.(data, ignoreDefault, f, queryResults, results);
         }
@@ -53,7 +66,7 @@ async function executeDependenciesQuery({ analyzer, }, queries) {
         ...results,
     };
 }
-function makeCallContextQuery(functions, kind) {
+function makeCallContextQuery([kind, functions]) {
     return functions.map(f => ({
         type: 'call-context',
         callName: f.name,
@@ -75,90 +88,95 @@ const readOnlyModes = new Set(['r', 'rt', 'rb']);
 const writeOnlyModes = new Set(['w', 'wt', 'wb', 'a', 'at', 'ab']);
 function getResults(queries, { dataflow, config, normalize }, results, kind, functions, data) {
     const defaultValue = (0, dependencies_query_format_1.getAllCategories)(queries)[kind].defaultValue;
+    const vars = config.solver.variables;
     const functionMap = new Map(functions.map(f => [f.name, f]));
     const kindEntries = Object.entries(results?.kinds[kind]?.subkinds ?? {});
-    return kindEntries.flatMap(([name, results]) => results.flatMap(({ id, linkedIds }) => {
-        const vertex = dataflow.graph.getVertex(id);
-        const info = functionMap.get(name);
-        const args = (0, resolve_argument_1.getArgumentStringValue)(config.solver.variables, dataflow.graph, vertex, info.argIdx, info.argName, info.resolveValue, data.analyzer.inspectContext());
-        const linkedArgs = collectValuesFromLinks(args, { dataflow, config, ctx: data.analyzer.inspectContext() }, linkedIds);
-        const linked = dropInfoOnLinkedIds(linkedIds);
-        function ignoreOnArgVal() {
-            if (info.ignoreIf === 'arg-true' || info.ignoreIf === 'arg-false') {
-                const margs = info.additionalArgs?.val;
-                (0, assert_1.guard)(margs, 'Need additional argument val when checking for arg-true');
-                const valArgs = (0, resolve_argument_1.getArgumentStringValue)(config.solver.variables, dataflow.graph, vertex, margs.argIdx, margs.argName, margs.resolveValue, data?.analyzer.inspectContext());
-                const valValues = valArgs?.values().flatMap(v => Array.from(v)).toArray() ?? [];
-                if (valValues.length === 0) {
-                    return false;
+    const finalResults = [];
+    const ictx = data.analyzer.inspectContext();
+    const d = ictx.deps;
+    const dfg = dataflow.graph;
+    for (const [name, results] of kindEntries) {
+        for (const { id, linkedIds } of results) {
+            const vertex = dfg.getVertex(id);
+            const info = functionMap.get(name);
+            const args = (0, resolve_argument_1.getArgumentStringValue)(vars, dfg, vertex, info.argIdx, info.argName, info.resolveValue, ictx);
+            const linkedArgs = collectValuesFromLinks(args, { dataflow, config, ctx: ictx }, linkedIds);
+            const linked = dropInfoOnLinkedIds(linkedIds);
+            function ignoreOnArgVal() {
+                if (info.ignoreIf === 'arg-true' || info.ignoreIf === 'arg-false') {
+                    const margs = info.additionalArgs?.val;
+                    (0, assert_1.guard)(margs, 'Need additional argument val when checking for arg-true');
+                    const valArgs = (0, resolve_argument_1.getArgumentStringValue)(vars, dfg, vertex, margs.argIdx, margs.argName, margs.resolveValue, data?.analyzer.inspectContext());
+                    const valValues = valArgs?.values().flatMap(v => Array.from(v)).toArray() ?? [];
+                    if (valValues.length === 0) {
+                        return false;
+                    }
+                    if (info.ignoreIf === 'arg-true' && valValues.every(v => v === 'TRUE')) {
+                        // all values are TRUE, so we can ignore this
+                        return true;
+                    }
+                    else if (info.ignoreIf === 'arg-false' && valValues.every(v => v === 'FALSE')) {
+                        // all values are FALSE, so we can ignore this
+                        return true;
+                    }
                 }
-                if (info.ignoreIf === 'arg-true' && valValues.every(v => v === 'TRUE')) {
-                    // all values are TRUE, so we can ignore this
-                    return true;
+                return false;
+            }
+            const foundValues = linkedArgs ?? args;
+            if (!foundValues) {
+                if (info.ignoreIf === 'arg-missing') {
+                    continue;
                 }
-                else if (info.ignoreIf === 'arg-false' && valValues.every(v => v === 'FALSE')) {
-                    // all values are FALSE, so we can ignore this
-                    return true;
+                else if (ignoreOnArgVal()) {
+                    continue;
                 }
-            }
-            return false;
-        }
-        const foundValues = linkedArgs ?? args;
-        if (!foundValues) {
-            if (info.ignoreIf === 'arg-missing') {
-                return [];
-            }
-            else if (ignoreOnArgVal()) {
-                return [];
-            }
-            const record = (0, objects_1.compactRecord)({
-                nodeId: id,
-                functionName: vertex.name,
-                lexemeOfArgument: undefined,
-                linkedIds: linked?.length ? linked : undefined,
-                value: info.defaultValue ?? defaultValue
-            });
-            return record ? [record] : [];
-        }
-        else if (info.ignoreIf === 'mode-only-read' || info.ignoreIf === 'mode-only-write') {
-            (0, assert_1.guard)('mode' in (info.additionalArgs ?? {}), 'Need additional argument mode when checking for mode');
-            const margs = info.additionalArgs?.mode;
-            (0, assert_1.guard)(margs, 'Need additional argument mode when checking for mode');
-            const modeArgs = (0, resolve_argument_1.getArgumentStringValue)(config.solver.variables, dataflow.graph, vertex, margs.argIdx, margs.argName, margs.resolveValue, data?.analyzer.inspectContext());
-            const modeValues = modeArgs?.values().flatMap(v => Array.from(v)) ?? [];
-            if (info.ignoreIf === 'mode-only-read' && modeValues.every(m => m && readOnlyModes.has(m))) {
-                // all modes are read-only, so we can ignore this
-                return [];
-            }
-            else if (info.ignoreIf === 'mode-only-write' && modeValues.every(m => m && writeOnlyModes.has(m))) {
-                // all modes are write-only, so we can ignore this
-                return [];
-            }
-        }
-        else if (ignoreOnArgVal()) {
-            return [];
-        }
-        const results = [];
-        for (const [arg, values] of foundValues.entries()) {
-            for (const value of values) {
-                const dep = value ? data?.analyzer.inspectContext().deps.getDependency(value) ?? undefined : undefined;
-                const result = (0, objects_1.compactRecord)({
+                const record = (0, objects_1.compactRecord)({
                     nodeId: id,
                     functionName: vertex.name,
-                    lexemeOfArgument: getLexeme(value, arg),
+                    lexemeOfArgument: undefined,
                     linkedIds: linked?.length ? linked : undefined,
-                    value: value ?? info.defaultValue ?? defaultValue,
-                    versionConstraints: dep?.versionConstraints,
-                    derivedVersion: dep?.derivedVersion,
-                    namespaceInfo: dep?.namespaceInfo
+                    value: info.defaultValue ?? defaultValue
                 });
-                if (result) {
-                    results.push(result);
+                if (record) {
+                    finalResults.push(record);
+                }
+                continue;
+            }
+            else if (info.ignoreIf === 'mode-only-read' || info.ignoreIf === 'mode-only-write') {
+                const margs = info.additionalArgs?.mode;
+                (0, assert_1.guard)(margs, 'Need additional argument mode when checking for mode');
+                const modeArgs = (0, resolve_argument_1.getArgumentStringValue)(vars, dfg, vertex, margs.argIdx, margs.argName, margs.resolveValue, data?.analyzer.inspectContext());
+                const modeValues = modeArgs?.values().flatMap(v => Array.from(v)) ?? [];
+                if (info.ignoreIf === 'mode-only-read' && modeValues.every(m => m && readOnlyModes.has(m))) {
+                    // all modes are read-only, so we can ignore this
+                    continue;
+                }
+                else if (info.ignoreIf === 'mode-only-write' && modeValues.every(m => m && writeOnlyModes.has(m))) {
+                    // all modes are write-only, so we can ignore this
+                    continue;
+                }
+            }
+            else if (ignoreOnArgVal()) {
+                continue;
+            }
+            for (const [arg, values] of foundValues.entries()) {
+                for (const value of values) {
+                    const dep = value ? d.getDependency(value) ?? undefined : undefined;
+                    finalResults.push((0, objects_1.compactRecord)({
+                        nodeId: id,
+                        functionName: vertex.name,
+                        lexemeOfArgument: getLexeme(value, arg),
+                        linkedIds: linked?.length ? linked : undefined,
+                        value: value ?? info.defaultValue ?? defaultValue,
+                        versionConstraints: dep?.versionConstraints,
+                        derivedVersion: dep?.derivedVersion,
+                        namespaceInfo: dep?.namespaceInfo
+                    }));
                 }
             }
         }
-        return results;
-    })) ?? [];
+    }
+    return finalResults;
     function getLexeme(argument, id) {
         if ((argument && argument !== dependencies_query_format_1.Unknown) || !id) {
             return undefined;
@@ -174,7 +192,7 @@ function collectValuesFromLinks(args, data, linkedIds) {
     if (!linkedIds || linkedIds.length === 0) {
         return undefined;
     }
-    const hasAtLeastAValue = args !== undefined && [...args.values()].some(set => [...set].some(v => v !== dependencies_query_format_1.Unknown && v !== undefined));
+    const hasAtLeastAValue = args !== undefined && args.values().flatMap(x => Array.from(x)).toArray().some(v => v !== dependencies_query_format_1.Unknown && v !== undefined);
     const map = new Map();
     for (const linkedId of linkedIds) {
         if (typeof linkedId !== 'object' || !linkedId.info) {
@@ -187,7 +205,7 @@ function collectValuesFromLinks(args, data, linkedIds) {
         }
         // collect this one!
         const vertex = data.dataflow.graph.getVertex(linkedId.id);
-        if (vertex === undefined || vertex.tag !== vertex_1.VertexType.FunctionCall) {
+        if (vertex?.tag !== vertex_1.VertexType.FunctionCall) {
             continue;
         }
         const args = (0, resolve_argument_1.getArgumentStringValue)(data.config.solver.variables, data.dataflow.graph, vertex, info.argIdx, info.argName, info.resolveValue, data.ctx);
@@ -209,7 +227,7 @@ function getFunctionsToCheck(customFunctions, functionFlag, enabled, ignoreDefau
     if (enabled !== undefined && (enabled?.length === 0 || enabled.indexOf(functionFlag) < 0)) {
         return [];
     }
-    let functions = ignoreDefaultFunctions ? [] : [...defaultFunctions];
+    let functions = ignoreDefaultFunctions ? [] : defaultFunctions.slice();
     if (customFunctions) {
         functions = functions.concat(customFunctions);
     }

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeDfShapeQuery = executeDfShapeQuery;
 const shape_inference_1 = require("../../../abstract-interpretation/data-frame/shape-inference");
+const cfg_kind_1 = require("../../../project/cfg-kind");
 const parse_1 = require("../../../slicing/criterion/parse");
 const log_1 = require("../../../util/log");
 /**
@@ -14,7 +15,7 @@ async function executeDfShapeQuery({ analyzer }, queries) {
     }
     const ast = await analyzer.normalize();
     const dfg = (await analyzer.dataflow()).graph;
-    const cfg = await analyzer.controlflow();
+    const cfg = await analyzer.controlflow(undefined, cfg_kind_1.CfgKind.NoFunctionDefs);
     const start = Date.now();
     const inference = new shape_inference_1.DataFrameShapeInferenceVisitor({ controlFlow: cfg, dfg, normalizedAst: ast, ctx: analyzer.inspectContext() });
     inference.start();
@@ -37,10 +38,16 @@ async function executeDfShapeQuery({ analyzer }, queries) {
             log_1.log.warn('Duplicate criterion in dataframe shape query:', query.criterion);
             continue;
         }
-        const nodeId = (0, parse_1.slicingCriterionToId)(query.criterion, ast.idMap);
-        const node = ast.idMap.get(nodeId);
-        const value = inference.getAbstractValue(node?.info.id);
-        result.set(query.criterion, value);
+        try {
+            const nodeId = (0, parse_1.slicingCriterionToId)(query.criterion, ast.idMap);
+            const node = ast.idMap.get(nodeId);
+            const value = inference.getAbstractValue(node?.info.id);
+            result.set(query.criterion, value);
+        }
+        catch (e) {
+            console.error(e instanceof Error ? e.message : e);
+            continue;
+        }
     }
     return {
         '.meta': {

package/queries/query.js

@@ -73,10 +73,11 @@ exports.SupportedQueries = {
  */
 async function executeQueriesOfSameType(data, queries) {
     (0, assert_1.guard)(queries.length > 0, 'At least one query must be provided');
+    const qzt = queries[0].type;
     /* every query must have the same type */
-    (0, assert_1.guard)(queries.every(q => q.type === queries[0].type), 'All queries must have the same type');
-    const query = exports.SupportedQueries[queries[0].type];
-    (0, assert_1.guard)(query !== undefined, `Unsupported query type: ${queries[0].type}`);
+    (0, assert_1.guard)(queries.every(q => q.type === qzt), 'All queries must have the same type');
+    const query = exports.SupportedQueries[qzt];
+    (0, assert_1.guard)(query !== undefined, `Unsupported query type: ${qzt}`);
     return query.executor(data, queries);
 }
 function isVirtualQuery(query) {

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

@@ -664,6 +664,26 @@ export declare const flowrCapabilities: {
             readonly id: "system-calls";
             readonly supported: "not";
             readonly description: "_Handle [`system`](https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/system), `system.*`, ..._ We do not support system calls but treat them as unknown function calls.";
+        }, {
+            readonly name: "R-Markdown files";
+            readonly id: "file:rmd";
+            readonly supported: "fully";
+            readonly description: "Support R-Markdown files as R sources.";
+        }, {
+            readonly name: "Jupyter Notebook";
+            readonly id: "file:ipynb";
+            readonly supported: "partially";
+            readonly description: "Support Jupyter Notebooks as R sources.";
+        }, {
+            readonly name: "Quarto";
+            readonly id: "file:qmd";
+            readonly supported: "partially";
+            readonly description: "Support Quarto files as R sources.";
+        }, {
+            readonly name: "Sweave";
+            readonly id: "file:rnw";
+            readonly supported: "partially";
+            readonly description: "Support for Sweave files as R sources.";
         }];
     }, {
         readonly name: "Pre-Processors/external Tooling";

package/r-bridge/data/data.js

@@ -829,6 +829,30 @@ ${await (0, doc_dfg_1.printDfGraphForCode)(parser, code, { simplified: true })}
                     id: 'system-calls',
                     supported: 'not',
                     description: '_Handle [`system`](https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/system), `system.*`, ..._ We do not support system calls but treat them as unknown function calls.'
+                },
+                {
+                    name: 'R-Markdown files',
+                    id: 'file:rmd',
+                    supported: 'fully',
+                    description: 'Support R-Markdown files as R sources.'
+                },
+                {
+                    name: 'Jupyter Notebook',
+                    id: 'file:ipynb',
+                    supported: 'partially',
+                    description: 'Support Jupyter Notebooks as R sources.'
+                },
+                {
+                    name: 'Quarto',
+                    id: 'file:qmd',
+                    supported: 'partially',
+                    description: 'Support Quarto files as R sources.'
+                },
+                {
+                    name: 'Sweave',
+                    id: 'file:rnw',
+                    supported: 'partially',
+                    description: 'Support for Sweave files as R sources.'
                 }
             ]
         },

package/r-bridge/lang-4.x/convert-values.js

@@ -86,7 +86,7 @@ function number2ts(value) {
     // check for hexadecimal number with floating point addon which is supported by R but not by JS :/
     let lcValue = value.toLowerCase();
     /* both checks are case-sensitive! */
-    const last = value[value.length - 1];
+    const last = value.at(-1);
     const markedAsInt = last === exports.RIntegerMarker;
     const complexNumber = last === exports.RImaginaryMarker;
     if (markedAsInt || complexNumber) {

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

@@ -27,16 +27,17 @@ function normalizeTreeSitterTreeToAst(tree, lax) {
     else {
         makeTreeSitterStrict();
     }
-    const files = tree.map(t => {
+    const files = [];
+    for (const t of tree) {
         const root = convertTreeNode(t.parsed.rootNode);
         if (root.type !== type_1.RType.ExpressionList) {
             throw new normalizer_data_1.ParseError(`expected root to resolve to an expression list, got a ${root.type}`);
         }
-        return {
+        files.push({
             filePath: t.filePath,
             root: root
-        };
-    });
+        });
+    }
     return {
         type: type_1.RType.Project,
         files
@@ -158,7 +159,7 @@ function convertTreeNode(node) {
                         treeSitterId: lhs.info.treeSitterId
                     }
                 };
-                if (op.type == 'special') {
+                if (op.type === 'special') {
                     return {
                         type: type_1.RType.FunctionCall,
                         location: opSource,
@@ -329,7 +330,7 @@ function convertTreeNode(node) {
             case tree_sitter_types_1.TreeSitterType.Call: {
                 const [func, argsParentheses] = nonErrorChildren(node);
                 // tree-sitter wraps next and break in a function call, but we don't, so unwrap
-                if (func.type === tree_sitter_types_1.TreeSitterType.Next || func.type == tree_sitter_types_1.TreeSitterType.Break) {
+                if (func.type === tree_sitter_types_1.TreeSitterType.Next || func.type === tree_sitter_types_1.TreeSitterType.Break) {
                     return {
                         ...convertTreeNode(func),
                         ...defaultInfo
@@ -339,7 +340,7 @@ function convertTreeNode(node) {
                 const [comments, noCommentrawArgs] = splitComments(rawArgs);
                 const args = (0, arrays_1.splitArrayOn)(noCommentrawArgs.slice(1, -1), x => x.type === 'comma');
                 const funcRange = makeSourceRange(func);
-                const mappedArgs = args.map(n => n.length == 0 ? r_function_call_1.EmptyArgument : convertTreeNode(n[0]));
+                const mappedArgs = args.map(n => n.length === 0 ? r_function_call_1.EmptyArgument : convertTreeNode(n[0]));
                 const call = {
                     arguments: mappedArgs,
                     location: funcRange,
@@ -424,14 +425,20 @@ function convertTreeNode(node) {
                 return {
                     type: type_1.RType.Logical,
                     location: range,
-                    content: (0, convert_values_1.boolean2ts)(node.text),
+                    content: node.text === convert_values_1.RTrue,
                     lexeme: node.text,
                     ...defaultInfo
                 };
             case tree_sitter_types_1.TreeSitterType.Break:
+                return {
+                    type: type_1.RType.Break,
+                    location: range,
+                    lexeme: node.text,
+                    ...defaultInfo
+                };
             case tree_sitter_types_1.TreeSitterType.Next:
                 return {
-                    type: node.type == tree_sitter_types_1.TreeSitterType.Break ? type_1.RType.Break : type_1.RType.Next,
+                    type: type_1.RType.Next,
                     location: range,
                     lexeme: node.text,
                     ...defaultInfo
@@ -447,7 +454,7 @@ function convertTreeNode(node) {
                     type: type_1.RType.Access,
                     operator: bracket.text,
                     accessed: convertTreeNode(func),
-                    access: args.map(n => n.length == 0 ? r_function_call_1.EmptyArgument : convertTreeNode(n[0])),
+                    access: args.map(n => n.length === 0 ? r_function_call_1.EmptyArgument : convertTreeNode(n[0])),
                     location: makeSourceRange(bracket),
                     lexeme: bracket.text,
                     ...defaultInfo
@@ -486,7 +493,7 @@ function convertTreeNode(node) {
                 const name = children[0];
                 const nameRange = makeSourceRange(name);
                 let defaultValue = undefined;
-                if (children.length == 3) {
+                if (children.length === 3) {
                     defaultValue = convertTreeNode(children[2]);
                 }
                 return {
@@ -517,7 +524,7 @@ function convertTreeNode(node) {
             }
             case tree_sitter_types_1.TreeSitterType.Argument: {
                 const children = nonErrorChildren(node);
-                if (children.length == 1) {
+                if (children.length === 1) {
                     const [arg] = children;
                     return {
                         type: type_1.RType.Argument,
@@ -596,21 +603,14 @@ function makeSourceRange(node) {
     if (!node) {
         return range_1.SourceRange.invalid();
     }
-    if (node.startPosition && node.endPosition) {
-        return [
-            // tree-sitter is 0-based but we want 1-based
-            node.startPosition.row + 1, node.startPosition.column + 1,
-            // tree-sitter's end position is one off from ours, so we don't add 1 here
-            node.endPosition.row + 1, node.endPosition.column
-        ];
-    }
-    else {
-        return [
-            (node.startPosition?.row ?? -2) + 1, (node.startPosition?.column ?? -2) + 1,
-            // tree-sitter's end position is one off from ours, so we don't add 1 here
-            (node.endPosition?.row ?? -2) + 1, node.endPosition?.column ?? -1
-        ];
-    }
+    const s = node.startPosition;
+    const e = node.endPosition;
+    return [
+        // tree-sitter is 0-based but we want 1-based
+        (s?.row ?? -2) + 1, (s?.column ?? -2) + 1,
+        // tree-sitter's end position is one off from ours, so we don't add 1 here
+        (e?.row ?? -2) + 1, e?.column ?? -1
+    ];
 }
 function splitComments(nodes) {
     const comments = [];
@@ -634,22 +634,52 @@ function splitComments(nodes) {
     }
     return [comments, others];
 }
+/**
+ * Find the first sibling of the given node that is not a comment, starting from the given node and going to the right.
+ * @param snode - the node for which to find the first non-comment sibling
+ * @param knownNexts - cache map from node id to the id of the first non-comment sibling
+ */
+function findFirstNonCommentSibling(snode, knownNexts) {
+    const cache = knownNexts.get(snode.id);
+    if (cache !== undefined) {
+        return cache;
+    }
+    const cursor = snode.parent?.walk();
+    if (!cursor) {
+        return null;
+    }
+    const linkCaches = [snode.id];
+    cursor.gotoFirstChild();
+    while (cursor.nodeId !== snode.id && cursor.gotoNextSibling()) {
+        /* skip */
+    }
+    cursor.gotoNextSibling();
+    while (cursor.nodeType === tree_sitter_types_1.TreeSitterType.Comment && cursor.gotoNextSibling()) {
+        /* skip */
+        linkCaches.push(cursor.nodeId);
+    }
+    const cur = cursor.currentNode;
+    for (const id of linkCaches) {
+        knownNexts.set(id, cur);
+    }
+    cursor.delete();
+    return cur;
+}
 function linkCommentsToNextNodes(nodes, comments) {
     const remain = [];
+    const cacheMap = new Map();
     for (const [commentSyntaxNode, commentNode] of comments) {
         let sibling;
-        if (commentSyntaxNode.previousSibling?.endIndex === commentSyntaxNode.startIndex) {
+        const prev = commentSyntaxNode.previousSibling;
+        if (prev?.endIndex === commentSyntaxNode.startIndex) {
             // if there is a sibling on the same line, we link the comment to that node
-            sibling = commentSyntaxNode.previousSibling;
+            sibling = prev;
         }
         else {
-            sibling = commentSyntaxNode.nextSibling;
-            while (sibling && sibling.type === tree_sitter_types_1.TreeSitterType.Comment) {
-                sibling = sibling.nextSibling;
-            }
+            sibling = findFirstNonCommentSibling(commentSyntaxNode, cacheMap);
         }
         // if there is no valid sibling, we just link the comment to the first node (see normalize-expressions.ts)
-        const [, node] = (sibling ? nodes.find(([s]) => s.equals(sibling)) : undefined) ?? nodes[0] ?? [];
+        const [, node] = (sibling ? nodes.find(([s]) => s.id === sibling.id) : undefined) ?? nodes[0] ?? [];
         if (node) {
             node.info.adToks ??= [];
             node.info.adToks.push(commentNode);

package/util/r-regex.d.ts

@@ -19,3 +19,7 @@ export declare const RStandardRegexp: {
  * ```
  */
 export declare const RPunctuationChars = "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";
+/**
+ * Converts an R regex pattern (which may include POSIX character classes) into a JavaScript RegExp.
+ */
+export declare function parseRRegexPattern(pattern: string): RegExp;

package/util/r-regex.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RPunctuationChars = exports.RStandardRegexp = void 0;
+exports.parseRRegexPattern = parseRRegexPattern;
 /**
  * Represents R's `.standard_regexps` definitions.
  * @see https://github.com/r-devel/r-svn/blob/44474af03ae77fd3b9a340279fa10cb698d106c3/src/library/base/R/utils.R#L52-L53
@@ -9,11 +10,11 @@ exports.RStandardRegexp = {
     /** `[[:alpha:]][[:alnum:].]*[[:alnum:]]` */
     ValidPackageName: (/[A-Za-z][A-Za-z0-9._]*[A-Za-z0-9]/),
     /** `([[:digit:]]+[.-]){1,}[[:digit:]]+` */
-    ValidPackageVersion: (/([0-9]+[.-])+[0-9]+/),
+    ValidPackageVersion: (/(\d+[.-])+\d+/),
     /** `[[:digit:]]+\\.[[:digit:]]+\\.[[:digit:]]+` */
-    ValidRSystemVersion: (/[0-9]+\.[0-9]+\.[0-9]+/),
+    ValidRSystemVersion: (/\d+\.\d+\.\d+/),
     /** `([[:digit:]]+[.-])*[[:digit:]]+` */
-    ValidNumericVersion: /([0-9]+[.-])*[0-9]+/
+    ValidNumericVersion: /(\d+[.-])*\d+/
 };
 /**
  * Based on the C-definition:
@@ -22,4 +23,35 @@ exports.RStandardRegexp = {
  * ```
  */
 exports.RPunctuationChars = '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~';
+const PosixClassMap = {
+    digit: '0-9',
+    lower: 'a-z',
+    upper: 'A-Z',
+    alpha: 'A-Za-z',
+    alnum: 'A-Za-z0-9',
+    space: String.raw `\s`,
+    blank: String.raw ` \t`,
+    punct: "!\"#$%&'()*+,\\-./:;<=>?@[\\\\\\]^_`{|}~",
+    xdigit: 'A-Fa-f0-9',
+    ascii: '\x00-\x7F',
+    cntrl: '\x00-\x1F\x7F',
+    graph: '\x21-\x7E',
+    word: 'A-Za-z0-9_',
+    print: '\x20-\x7E'
+};
+const posixClassRegex = /\[:([a-z]+):]/g;
+/**
+ * Converts an R regex pattern (which may include POSIX character classes) into a JavaScript RegExp.
+ */
+function parseRRegexPattern(pattern) {
+    let convertedPattern = pattern.replaceAll(posixClassRegex, (s, className) => {
+        const charClass = PosixClassMap[className];
+        return charClass ?? s;
+    });
+    // we also want to support a glob '*' without any prefix:
+    if (convertedPattern.startsWith('*') || convertedPattern.startsWith('+')) {
+        convertedPattern = '.' + convertedPattern;
+    }
+    return new RegExp(convertedPattern);
+}
 //# sourceMappingURL=r-regex.js.map

package/util/version.js

@@ -6,7 +6,7 @@ exports.printVersionInformation = printVersionInformation;
 const semver_1 = require("semver");
 const assert_1 = require("./assert");
 // this is automatically replaced with the current version by release-it
-const version = '2.9.5';
+const version = '2.9.7';
 /**
  * Retrieves the current flowR version as a new {@link SemVer} object.
  */