@eagleoutice/flowr 2.8.1 → 2.8.3

package/dataflow/environments/default-builtin-config.d.ts

@@ -101,7 +101,7 @@ export declare const DefaultBuiltinConfig: [{
     readonly assumePrimitive: false;
 }, {
     readonly type: "function";
-    readonly names: ["print", "message", "warning"];
+    readonly names: ["print", "message", "warning", "warn", "info"];
     readonly processor: "builtin:default";
     readonly config: {
         readonly returnsNthArgument: 0;
@@ -262,7 +262,7 @@ export declare const DefaultBuiltinConfig: [{
     readonly assumePrimitive: true;
 }, {
     readonly type: "function";
-    readonly names: ["stop", "abort"];
+    readonly names: ["stop", "abort", "cli_abort", "throw", "stop_bad_type", "stop_bad_element_type", "stop_bad_element_length"];
     readonly processor: "builtin:default";
     readonly config: {
         readonly useAsProcessor: "builtin:stop";

package/dataflow/environments/default-builtin-config.js

@@ -129,7 +129,7 @@ exports.DefaultBuiltinConfig = [
     { type: 'function', names: ['lapply', 'sapply', 'vapply'], processor: 'builtin:apply', config: { indexOfFunction: 1, nameOfFunctionArgument: 'FUN' }, assumePrimitive: false },
     { type: 'function', names: ['Lapply', 'Sapply', 'Vapply'], processor: 'builtin:apply', config: { indexOfFunction: 1, nameOfFunctionArgument: 'FUN' }, assumePrimitive: false }, /* functool wrappers */
     { type: 'function', names: ['apply', 'tapply', 'Tapply'], processor: 'builtin:apply', config: { indexOfFunction: 2, nameOfFunctionArgument: 'FUN' }, assumePrimitive: false },
-    { type: 'function', names: ['print', 'message', 'warning'], processor: 'builtin:default', config: { returnsNthArgument: 0, forceArgs: 'all', hasUnknownSideEffects: { type: 'link-to-last-call', callName: /^sink$/ } }, assumePrimitive: false },
+    { type: 'function', names: ['print', 'message', 'warning', 'warn', 'info'], processor: 'builtin:default', config: { returnsNthArgument: 0, forceArgs: 'all', hasUnknownSideEffects: { type: 'link-to-last-call', callName: /^sink$/ } }, assumePrimitive: false },
     // graphics base
     { type: 'function', names: exports.PlotCreate,
         processor: 'builtin:default',
@@ -232,7 +232,13 @@ exports.DefaultBuiltinConfig = [
     { type: 'function', names: ['cat'], processor: 'builtin:default', config: { forceArgs: 'all', hasUnknownSideEffects: { type: 'link-to-last-call', callName: /^sink$/ } }, assumePrimitive: false },
     { type: 'function', names: ['switch'], processor: 'builtin:default', config: { forceArgs: [true] }, assumePrimitive: false },
     { type: 'function', names: ['return'], processor: 'builtin:default', config: { returnsNthArgument: 0, cfg: 1 /* ExitPointType.Return */, useAsProcessor: 'builtin:return' }, assumePrimitive: true },
-    { type: 'function', names: ['stop', 'abort'], processor: 'builtin:default', config: { useAsProcessor: 'builtin:stop', cfg: 4 /* ExitPointType.Error */, forceArgs: ['all'] }, assumePrimitive: false },
+    {
+        type: 'function',
+        names: ['stop', 'abort', 'cli_abort', 'throw', 'stop_bad_type', 'stop_bad_element_type', 'stop_bad_element_length'],
+        processor: 'builtin:default',
+        config: { useAsProcessor: 'builtin:stop', cfg: 4 /* ExitPointType.Error */, forceArgs: ['all'] },
+        assumePrimitive: false
+    },
     { type: 'function', names: ['try'], processor: 'builtin:try', config: { block: 'expr', handlers: {} }, assumePrimitive: true },
     { type: 'function', names: ['tryCatch', 'tryCatchLog'], processor: 'builtin:try', config: { block: 'expr', handlers: { error: 'error', finally: 'finally' } }, assumePrimitive: true },
     { type: 'function', names: ['stopifnot'], processor: 'builtin:stopifnot', config: {}, assumePrimitive: false },

package/dataflow/graph/call-graph.d.ts

@@ -1,9 +1,16 @@
 import { DataflowGraph } from './graph';
 import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexFunctionDefinition } from './vertex';
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 /**
  * A call graph is a dataflow graph where all vertices are function calls.
+ * You can create a call graph from a dataflow graph using {@link computeCallGraph}.
+ * If you want to extract a sub call graph, use {@link getSubCallGraph}.
  */
 export type CallGraph = DataflowGraph<Required<DataflowGraphVertexFunctionCall | DataflowGraphVertexFunctionDefinition>>;
+/**
+ * Extracts the sub call graph from the given call graph, starting from the given entry points.
+ */
+export declare function getSubCallGraph(graph: CallGraph, entryPoints: Set<NodeId>): CallGraph;
 /**
  * Computes the call graph from the given dataflow graph.
  */

package/dataflow/graph/call-graph.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSubCallGraph = getSubCallGraph;
 exports.computeCallGraph = computeCallGraph;
 const graph_1 = require("./graph");
 const vertex_1 = require("./vertex");
@@ -7,6 +8,33 @@ const linker_1 = require("../internal/linker");
 const edge_1 = require("./edge");
 const built_in_1 = require("../environments/built-in");
 const defaultmap_1 = require("../../util/collections/defaultmap");
+/**
+ * Extracts the sub call graph from the given call graph, starting from the given entry points.
+ */
+function getSubCallGraph(graph, entryPoints) {
+    const result = new graph_1.DataflowGraph(graph.idMap);
+    const toVisit = Array.from(entryPoints);
+    const visited = new Set();
+    while (toVisit.length > 0) {
+        const currentId = toVisit.pop();
+        if (visited.has(currentId)) {
+            continue;
+        }
+        visited.add(currentId);
+        const currentVtx = graph.getVertex(currentId, true);
+        if (!currentVtx) {
+            continue;
+        }
+        result.addVertex(currentVtx, undefined, true);
+        for (const [tar, { types }] of graph.outgoingEdges(currentId) ?? []) {
+            if ((0, edge_1.edgeIncludesType)(types, edge_1.EdgeType.Calls)) {
+                result.addEdge(currentId, tar, edge_1.EdgeType.Calls);
+                toVisit.push(tar);
+            }
+        }
+    }
+    return result;
+}
 function reaches(from, to, graph, knownReachability) {
     const visited = new Set();
     const toVisit = [from];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/flowr",
-  "version": "2.8.1",
+  "version": "2.8.3",
   "description": "Static Dataflow Analyzer and Program Slicer for the R Programming Language",
   "types": "dist/src/index.d.ts",
   "repository": {

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

@@ -4,6 +4,8 @@ export interface NamespaceInfo {
     exportedSymbols: string[];
     exportedFunctions: string[];
     exportS3Generics: Map<string, string[]>;
+    exportedPatterns: string[];
+    importedPackages: Map<string, string[] | 'all'>;
     loadsWithSideEffects: boolean;
 }
 export interface NamespaceFormat {

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowrNamespaceFile = void 0;
 const flowr_file_1 = require("../../../context/flowr-file");
+const resolve_args_1 = require("../../../../abstract-interpretation/data-frame/resolve-args");
 /**
  * This decorates a text file and provides access to its content in the {@link NamespaceFormat}.
  */
@@ -43,6 +44,8 @@ function parseNamespace(file) {
             exportedSymbols: [],
             exportedFunctions: [],
             exportS3Generics: new Map(),
+            exportedPatterns: [],
+            importedPackages: new Map(),
             loadsWithSideEffects: false,
         },
     };
@@ -89,12 +92,37 @@ function parseNamespace(file) {
                             exportedSymbols: [],
                             exportedFunctions: [],
                             exportS3Generics: new Map(),
+                            exportedPatterns: [],
+                            importedPackages: new Map(),
                             loadsWithSideEffects: false,
                         };
                     }
                     result[pkg].loadsWithSideEffects = true;
                     break;
                 }
+            case 'import': {
+                const pkg = args.trim();
+                result.current.importedPackages?.set(pkg, 'all');
+                break;
+            }
+            case 'importFrom': {
+                const parts = args.split(',').map(s => s.trim());
+                if (parts.length < 2) {
+                    continue;
+                }
+                const [pkg, ...symbols] = parts;
+                let arr = result.current.importedPackages?.get(pkg);
+                if (!arr || arr === 'all') {
+                    arr = [];
+                    result.current.importedPackages?.set(pkg, arr);
+                }
+                arr.push(...symbols);
+                break;
+            }
+            case 'exportPattern': {
+                result.current.exportedPatterns?.push((0, resolve_args_1.unquoteArgument)(args.trim()));
+                break;
+            }
         }
     }
     return result;

package/project/plugins/flowr-analyzer-plugin.js

@@ -75,7 +75,7 @@ class FlowrAnalyzerPlugin {
         }
         catch (error) {
             const duration = Date.now() - now;
-            generalPluginLog.error(`Plugin ${this.name} (v${this.version.format()}, {this.type}) failed after ${duration}ms. Error: ${error.message}`);
+            generalPluginLog.error(`Plugin ${this.name} (v${this.version.format()}, ${this.type}) failed after ${duration}ms. Error: ${error.message}`);
             throw error;
         }
     }

package/project/plugins/project-discovery/flowr-analyzer-project-discovery-plugin.js

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowrAnalyzerProjectDiscoveryPlugin = void 0;
 const flowr_analyzer_plugin_1 = require("../flowr-analyzer-plugin");
@@ -6,6 +9,7 @@ const semver_1 = require("semver");
 const flowr_file_1 = require("../../context/flowr-file");
 const files_1 = require("../../../util/files");
 const built_in_source_1 = require("../../../dataflow/internal/process/functions/call/built-in/built-in-source");
+const path_1 = __importDefault(require("path"));
 /**
  * This is the base class for all plugins that discover files in a project for analysis.
  * These plugins interplay with the {@link FlowrAnalyzerFilesContext} to gather information about the files in the project.
@@ -52,11 +56,10 @@ class DefaultFlowrAnalyzerProjectDiscoveryPlugin extends FlowrAnalyzerProjectDis
     process(_context, args) {
         const requests = [];
         /* the dummy approach of collecting all files, group R and Rmd files, and be done with it */
-        for (const file of (0, files_1.getAllFilesSync)(args.content)) {
-            if (this.ignorePathsRegex.test(file)) {
-                continue;
-            }
-            if (this.supportedExtensions.test(file) && (!this.onlyTraversePaths || this.onlyTraversePaths.test(file)) && !this.excludePathsRegex.test((0, built_in_source_1.platformDirname)(file))) {
+        for (const file of (0, files_1.getAllFilesSync)(args.content, /.*/, this.ignorePathsRegex)) {
+            console.log(`Discovered file: ${file}`);
+            const relativePath = path_1.default.relative(args.content, file);
+            if (this.supportedExtensions.test(relativePath) && (!this.onlyTraversePaths || this.onlyTraversePaths.test(relativePath)) && !this.excludePathsRegex.test((0, built_in_source_1.platformDirname)(relativePath))) {
                 requests.push({ content: file, request: 'file' });
             }
             else {

package/queries/catalog/dependencies-query/function-info/write-functions.js

@@ -28,10 +28,14 @@ exports.WriteFunctions = [
         }
     },
     // write functions that don't have argIndex are assumed to write to stdout
-    { package: 'base', name: 'print', linkTo: OutputRedirects, resolveValue: true },
+    { package: 'base', name: 'print', linkTo: OutputRedirects, resolveValue: false },
     { package: 'base', name: 'cat', linkTo: OutputRedirects, argName: 'file', resolveValue: true },
-    { package: 'base', name: 'message', linkTo: OutputRedirects, resolveValue: true },
-    { package: 'base', name: 'warning', linkTo: OutputRedirects, resolveValue: true },
+    { package: 'base', name: 'message', linkTo: OutputRedirects, resolveValue: false },
+    { package: 'base', name: 'warning', linkTo: OutputRedirects, resolveValue: false },
+    { package: 'rlang', name: 'warn', linkTo: OutputRedirects, resolveValue: false },
+    { package: 'rlang', name: 'info', linkTo: OutputRedirects, resolveValue: false },
+    { package: 'cli', name: 'cli_warn', linkTo: OutputRedirects, resolveValue: false },
+    { package: 'cli', name: 'cli_abort', linkTo: OutputRedirects, resolveValue: false },
     { package: 'base', name: 'writeLines', argIdx: 1, argName: 'con', resolveValue: true },
     { package: 'base', name: 'writeChar', argIdx: 1, argName: 'con', resolveValue: true },
     { package: 'base', name: 'writeBin', argIdx: 1, argName: 'con', resolveValue: true },

package/queries/query.js

@@ -169,7 +169,7 @@ async function genericWrapReplFailIfNoRequest(fn, output, analyzer) {
             output.stderr(output.formatter.format('No requests to analyze were found.', { color: 1 /* Colors.Red */, style: 1 /* FontStyles.Bold */, effect: ansi_1.ColorEffect.Foreground })
                 + '\nIf you consider this an error, please report a bug: '
                 + (0, assert_1.getGuardIssueUrl)('analyzer found no requests to analyze'));
-            output.stderr((e instanceof Error) ? e.message : String(e));
+            output.stderr('Full error message: ' + ((e instanceof Error) ? e.message : String(e)));
         }
         else {
             throw e;

package/r-bridge/roxygen2/documentation-provider.d.ts

@@ -0,0 +1,15 @@
+import type { AstIdMap, ParentInformation } from '../lang-4.x/ast/model/processing/decorate';
+import type { NodeId } from '../lang-4.x/ast/model/processing/node-id';
+import type { RoxygenTag } from './roxygen-ast';
+export interface DocumentationInfo {
+    doc?: Documentation;
+}
+export type Documentation = RoxygenTag | readonly RoxygenTag[];
+/**
+ * Given a normalized AST and a node ID, returns the Roxygen documentation (if any) associated with that node.
+ * Please note that this does more than {@link parseRoxygenCommentsOfNode}, as it also traverses up the AST to find documentation.
+ * Additionally, this function instruments the normalized AST to cache the parsed documentation for future queries.
+ * @param idMap   - The AST ID map to use for looking up nodes and traversing the AST.
+ * @param nodeId  - The ID of the node to get documentation for.
+ */
+export declare function getDocumentationOf(nodeId: NodeId, idMap: AstIdMap<ParentInformation & DocumentationInfo>): Documentation | undefined;

package/r-bridge/roxygen2/documentation-provider.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDocumentationOf = getDocumentationOf;
+const roxygen_ast_1 = require("./roxygen-ast");
+const type_1 = require("../lang-4.x/ast/model/type");
+const roxygen_parse_1 = require("./roxygen-parse");
+const CommentRetriever = {
+    [type_1.RType.Comment]: n => (0, roxygen_parse_1.parseRoxygenComment)([n.lexeme]),
+    [type_1.RType.Parameter]: (n, idMap) => {
+        // get the documentation of the parent function
+        const doc = n.info.parent ? getDocumentationOf(n.info.parent, idMap) : undefined;
+        const paramName = n.lexeme;
+        if (doc && paramName) {
+            if (Array.isArray(doc)) {
+                const res = doc.filter(t => t.type === roxygen_ast_1.KnownRoxygenTags.Param && t.value.name === paramName);
+                if (res.length === 1) {
+                    return res[0];
+                }
+                else {
+                    return res;
+                }
+            }
+            else {
+                if (doc.type === roxygen_ast_1.KnownRoxygenTags.Param && doc.value.name === paramName) {
+                    return doc;
+                }
+            }
+        }
+        return undefined;
+    }
+};
+/**
+ * Given a normalized AST and a node ID, returns the Roxygen documentation (if any) associated with that node.
+ * Please note that this does more than {@link parseRoxygenCommentsOfNode}, as it also traverses up the AST to find documentation.
+ * Additionally, this function instruments the normalized AST to cache the parsed documentation for future queries.
+ * @param idMap   - The AST ID map to use for looking up nodes and traversing the AST.
+ * @param nodeId  - The ID of the node to get documentation for.
+ */
+function getDocumentationOf(nodeId, idMap) {
+    const node = idMap.get(nodeId);
+    if (!node) {
+        return undefined;
+    }
+    else if (node.info.doc) {
+        return node.info.doc;
+    }
+    const retriever = CommentRetriever[node.type] ?? ((c, a) => (0, roxygen_parse_1.parseRoxygenCommentsOfNode)(c, a)?.tags);
+    const doc = retriever(node, idMap);
+    if (doc) {
+        // cache the documentation for future queries
+        const expanded = expandInheritsOfTags(doc, idMap);
+        node.info.doc = expanded;
+        return expanded;
+    }
+    return doc;
+}
+function expandInheritsOfTags(tags, idMap) {
+    const expandedTags = [];
+    const tagArray = Array.isArray(tags) ? tags : [tags];
+    for (const tag of tagArray) {
+        const expanded = expandInheritOfTag(tag, tagArray, idMap);
+        if (!expanded) {
+            continue;
+        }
+        if (Array.isArray(expanded)) {
+            expandedTags.push(...expanded);
+        }
+        else {
+            expandedTags.push(expanded);
+        }
+    }
+    if (expandedTags.length === 1) {
+        return expandedTags[0];
+    }
+    return expandedTags;
+}
+function getDocumentationOfByName(name, idMap) {
+    for (const [, node] of idMap) {
+        const nodeName = node.lexeme ?? node.info.fullLexeme;
+        if (nodeName !== name) {
+            continue;
+        }
+        return getDocumentationOf(node.info.id, idMap);
+    }
+}
+function filterDocumentationForParams(doc, filter) {
+    if (!doc) {
+        return doc;
+    }
+    if (Array.isArray(doc)) {
+        return doc.filter(filter);
+    }
+    else {
+        return filter(doc) ? doc : undefined;
+    }
+}
+function expandInheritOfTag(tag, otherTags, idMap) {
+    if (tag.type === roxygen_ast_1.KnownRoxygenTags.Inherit) {
+        const inheritDoc = getDocumentationOfByName(tag.value.source, idMap);
+        return filterDocumentationForParams(inheritDoc, t => tag.value.components.includes(t.type));
+    }
+    else if (tag.type === roxygen_ast_1.KnownRoxygenTags.InheritDotParams) {
+        const inheritDoc = getDocumentationOfByName(tag.value.source, idMap);
+        return filterDocumentationForParams(inheritDoc, t => t.type === roxygen_ast_1.KnownRoxygenTags.Param && t.value.name === '...');
+    }
+    else if (tag.type === roxygen_ast_1.KnownRoxygenTags.InheritParams) {
+        const inheritDoc = getDocumentationOfByName(tag.value, idMap);
+        const alreadyExplainedParams = new Set(otherTags.filter(t => t.type === roxygen_ast_1.KnownRoxygenTags.Param).map(t => t.value.name));
+        return filterDocumentationForParams(inheritDoc, t => t.type === roxygen_ast_1.KnownRoxygenTags.Param && !alreadyExplainedParams.has(t.value.name));
+    }
+    return tag;
+}
+//# sourceMappingURL=documentation-provider.js.map

package/r-bridge/roxygen2/roxygen-parse.d.ts

@@ -4,6 +4,8 @@ import type { AstIdMap, ParentInformation } from '../lang-4.x/ast/model/processi
 /**
  * Parses the roxygen comments attached to a node into a RoxygenBlock AST node.
  * Will return `undefined` if there are no valid roxygen comments attached to the node.
+ * Please note that this does *not* do any clever mapping of parameters or requests.
+ * For a higher-level function that also traverses up the AST to find comments attached to parent nodes, see {@link getDocumentationOf}.
  * @param node  - The node to parse the roxygen comments for
  * @param idMap - An optional id map to traverse up the AST to find comments attached to parent nodes
  */

package/r-bridge/roxygen2/roxygen-parse.js

@@ -26,6 +26,8 @@ function prepareCommentContext(commentText) {
 /**
  * Parses the roxygen comments attached to a node into a RoxygenBlock AST node.
  * Will return `undefined` if there are no valid roxygen comments attached to the node.
+ * Please note that this does *not* do any clever mapping of parameters or requests.
+ * For a higher-level function that also traverses up the AST to find comments attached to parent nodes, see {@link getDocumentationOf}.
  * @param node  - The node to parse the roxygen comments for
  * @param idMap - An optional id map to traverse up the AST to find comments attached to parent nodes
  */

package/slicing/static/slice-call.d.ts

@@ -12,6 +12,6 @@ import type { ReadOnlyFlowrAnalyzerContext } from '../../project/context/flowr-a
  */
 export declare function getAllFunctionCallTargets(dataflowGraph: DataflowGraph, callerInfo: DataflowGraphVertexFunctionCall, baseEnvironment: REnvironmentInformation, queue: VisitingQueue, ctx: ReadOnlyFlowrAnalyzerContext): [Set<DataflowGraphVertexInfo>, REnvironmentInformation];
 /** returns the new threshold hit count */
-export declare function sliceForCall(current: NodeToSlice, callerInfo: DataflowGraphVertexFunctionCall, dataflowInformation: DataflowInformation, queue: VisitingQueue, ctx: ReadOnlyFlowrAnalyzerContext): void;
+export declare function sliceForCall(current: NodeToSlice, callerInfo: DataflowGraphVertexFunctionCall, { graph }: DataflowInformation, queue: VisitingQueue, ctx: ReadOnlyFlowrAnalyzerContext): void;
 /** Returns true if we found at least one return edge */
 export declare function handleReturns(from: NodeId, queue: VisitingQueue, currentEdges: OutgoingEdges, baseEnvFingerprint: Fingerprint, baseEnvironment: REnvironmentInformation): boolean;

package/slicing/static/slice-call.js

@@ -59,24 +59,25 @@ function linkCallTargets(onlyForSideEffects, functionCallTargets, activeEnvironm
     }
 }
 /** returns the new threshold hit count */
-function sliceForCall(current, callerInfo, dataflowInformation, queue, ctx) {
-    const [functionCallTargets, activeEnvironment] = getAllFunctionCallTargets(dataflowInformation.graph, callerInfo, current.baseEnvironment, queue, ctx);
-    const activeEnvironmentFingerprint = (0, fingerprint_1.envFingerprint)(activeEnvironment);
+function sliceForCall(current, callerInfo, { graph }, queue, ctx) {
+    const [functionCallTargets, activeEnvironment] = getAllFunctionCallTargets(graph, callerInfo, current.baseEnvironment, queue, ctx);
     if (functionCallTargets.size === 0) {
         /*
          * if we do not have any call to resolve this function, we have to assume that every function passed is actually called!
          * hence, we add a new flag and add all argument values to the queue causing directly
          */
         for (const arg of callerInfo.args) {
-            includeArgumentFunctionCallClosure(arg, activeEnvironment, queue, dataflowInformation.graph);
+            includeArgumentFunctionCallClosure(arg, activeEnvironment, queue, graph);
         }
         return;
     }
+    const activeEnvironmentFingerprint = (0, fingerprint_1.envFingerprint)(activeEnvironment);
     linkCallTargets(current.onlyForSideEffects, functionCallTargets, activeEnvironment, activeEnvironmentFingerprint, queue);
 }
+const PotentialFollowOnReturn = edge_1.EdgeType.DefinesOnCall | edge_1.EdgeType.DefinedByOnCall | edge_1.EdgeType.Argument;
 /** Returns true if we found at least one return edge */
 function handleReturns(from, queue, currentEdges, baseEnvFingerprint, baseEnvironment) {
-    const e = [...currentEdges.entries()];
+    const e = Array.from(currentEdges.entries());
     const found = e.filter(([_, edge]) => (0, edge_1.edgeIncludesType)(edge.types, edge_1.EdgeType.Returns));
     if (found.length === 0) {
         return false;
@@ -88,7 +89,7 @@ function handleReturns(from, queue, currentEdges, baseEnvFingerprint, baseEnviro
         if ((0, edge_1.edgeIncludesType)(edge.types, edge_1.EdgeType.Reads)) {
             queue.add(target, baseEnvironment, baseEnvFingerprint, false);
         }
-        else if ((0, edge_1.edgeIncludesType)(edge.types, edge_1.EdgeType.DefinesOnCall | edge_1.EdgeType.DefinedByOnCall | edge_1.EdgeType.Argument)) {
+        else if ((0, edge_1.edgeIncludesType)(edge.types, PotentialFollowOnReturn)) {
             (0, static_slicer_1.updatePotentialAddition)(queue, from, target, baseEnvironment, baseEnvFingerprint);
         }
     }

package/util/files.d.ts

@@ -19,7 +19,7 @@ export declare function getAllFiles(dir: string, suffix?: RegExp): AsyncGenerato
  * Retrieves all files in the given directory recursively (synchronously)
  * @see {@link getAllFiles} - for an asynchronous version.
  */
-export declare function getAllFilesSync(dir: string, suffix?: RegExp): Generator<string>;
+export declare function getAllFilesSync(dir: string, suffix?: RegExp, ignoreDirs?: RegExp | undefined): Generator<string>;
 /**
  * Retrieves all R files in a given directory (asynchronously)
  * @param input - directory-path to start the search from, can be a file as well. Will just return the file then.

package/util/files.js

@@ -72,12 +72,14 @@ async function* getAllFiles(dir, suffix = /.*/) {
  * Retrieves all files in the given directory recursively (synchronously)
  * @see {@link getAllFiles} - for an asynchronous version.
  */
-function* getAllFilesSync(dir, suffix = /.*/) {
+function* getAllFilesSync(dir, suffix = /.*/, ignoreDirs = undefined) {
     const entries = fs_1.default.readdirSync(dir, { withFileTypes: true, recursive: false });
     for (const subEntries of entries) {
         const res = path_1.default.resolve(dir, subEntries.name);
         if (subEntries.isDirectory()) {
-            yield* getAllFilesSync(res, suffix);
+            if (!ignoreDirs?.test(subEntries.name)) {
+                yield* getAllFilesSync(res, suffix);
+            }
         }
         else if (suffix.test(subEntries.name)) {
             yield res;

package/util/r-version.js

@@ -9,60 +9,47 @@ function makeVersion(version, original) {
     semver.str = original;
     return semver;
 }
-/**
- * Additionally, this transforms `a-b.c` into `a.0.0-b.c` and `a.b-c.d` into `a.b.0-c.d` to
- * ensure valid SemVer format.
- */
-function normalizeTooShortVersions(versions) {
-    const TooShortVersionRegex = /(^|(?<=[^\d.-]))(?<major>\d+)(\.(?<minor>\d+))?\.?-(?<prerelease>[0-9A-Za-z-.]+)(\s|$)/g;
-    let newVersions = '';
-    let match;
-    while ((match = TooShortVersionRegex.exec(versions)) !== null) {
-        const { major, minor, prerelease } = match.groups;
-        const prefix = versions.slice(0, match.index);
-        let newVersion = '';
-        if (minor === undefined) {
-            // only major version present
-            newVersion = `${major}.0.0-${prerelease}`;
-        }
-        else {
-            // major and minor version present, but dot before prerelease
-            newVersion = `${major}.${minor}.0-${prerelease}`;
+function normalizeVersion(version) {
+    version = version.trim();
+    let comparator = '';
+    // extract comparator if present
+    const comparatorMatch = version.match(/^([<>=~^]+)/);
+    if (comparatorMatch) {
+        comparator = comparatorMatch[1].replace('==', '=');
+        version = version.slice(comparatorMatch[1].length).trim();
+    }
+    const [mainVersion, ...preReleaseParts] = version.split('-');
+    const mainVersionParts = mainVersion.split('.');
+    if (mainVersionParts.length > 3) {
+        const newPreReleasePart = mainVersionParts.splice(3).join('.');
+        preReleaseParts.unshift(newPreReleasePart);
+    }
+    else {
+        while (mainVersionParts.length < 3) {
+            mainVersionParts.push('0');
         }
-        newVersions += `${prefix}${newVersion}`;
-        versions = versions.slice(match.index + match[0].length);
     }
-    newVersions += versions; // append any remaining part
-    return newVersions;
+    return comparator + mainVersionParts.map(n => String(Number(n))).join('.') + (preReleaseParts.length > 0 ? `-${preReleaseParts.join('-')}` : '');
 }
-/**
- * For every version `a.b.c.d.e...` converts it to `a.b.c-d.e...`
- * If the version already contains a prerelease part, it is appended:
- * `a.b.c.d.e-prerelease...` becomes `a.b.c-d.e-prerelease...`
- */
-function normalizeAdditionalVersionsToPrerelease(version) {
-    version = normalizeTooShortVersions(version);
-    const AdditionalVersionRegex = /(\d+\.\d+\.\d+)(?<additional>(\.\d+)+)(-(?<prerelease>[0-9A-Za-z-.]+))?/g;
+const AnyVerWithMaybeRangeRegex = /(\s*[<>=~^]*\s*\d+(\.\d*)*(-[0-9A-Za-z-.]+)?)/g;
+function normalizeVersions(versions) {
+    const parts = [];
+    // extract all version-like parts and normalize them individually
     let match;
-    let newVersion = '';
-    // repeat until no more matches
-    while ((match = AdditionalVersionRegex.exec(version)) !== null) {
-        // append to new version, first take over anything before the match
-        const prefix = version.slice(0, match.index);
-        const { additional, prerelease } = match.groups;
-        const additionalParts = additional.slice(1).split('.'); // remove leading dot and split
-        if (additionalParts.length === 0) {
-            continue; // nothing to do
+    let index = 0;
+    while ((match = AnyVerWithMaybeRangeRegex.exec(versions)) !== null) {
+        const prefix = versions.slice(index, match.index);
+        if (prefix.length > 0) {
+            parts.push(prefix);
         }
-        let newPrerelease = additionalParts.join('.');
-        if (prerelease) {
-            newPrerelease = `${newPrerelease}-${prerelease}`;
-        }
-        newVersion = `${prefix}${match[1]}-${newPrerelease}`;
-        version = version.slice(match.index + match[0].length);
+        const versionPart = match[1];
+        parts.push(normalizeVersion(versionPart));
+        index = match.index + versionPart.length;
+    }
+    if (index < versions.length) {
+        parts.push(versions.slice(index));
     }
-    newVersion += version; // append any remaining part
-    return newVersion;
+    return parts.join('');
 }
 /**
  * This parses an R version string and returns a SemVer object.
@@ -76,7 +63,7 @@ function parseRVersion(version) {
     }
     catch { /* do nothing */ }
     try {
-        const normalized = normalizeAdditionalVersionsToPrerelease(version);
+        const normalized = normalizeVersions(version);
         return makeVersion(normalized, version);
     }
     catch { /* do nothing */ }
@@ -100,7 +87,7 @@ function parseRRange(range) {
         return makeRange(range, range);
     }
     catch { /* try to normalize R range to SemVer */ }
-    const normalized = normalizeAdditionalVersionsToPrerelease(range);
-    return makeRange(normalized.replace(/==/g, '='), range);
+    const normalized = normalizeVersions(range);
+    return makeRange(normalized, range);
 }
 //# sourceMappingURL=r-version.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.8.1';
+const version = '2.8.3';
 /**
  * Retrieves the current flowR version as a new {@link SemVer} object.
  */