@eagleoutice/flowr 2.8.0 → 2.8.2

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

@@ -383,6 +383,7 @@ export declare const DefaultBuiltinConfig: [{
     readonly processor: "builtin:assignment";
     readonly config: {
         readonly targetVariable: true;
+        readonly mayHaveMoreArgs: true;
     };
     readonly assumePrimitive: true;
 }, {

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

@@ -247,7 +247,7 @@ exports.DefaultBuiltinConfig = [
     { type: 'function', names: ['library', 'require'], processor: 'builtin:library', config: {}, assumePrimitive: false },
     { type: 'function', names: ['<-', '='], processor: 'builtin:assignment', config: { canBeReplacement: true }, assumePrimitive: true },
     { type: 'function', names: [':='], processor: 'builtin:assignment', config: {}, assumePrimitive: true },
-    { type: 'function', names: ['assign', 'setGeneric', 'setValidity'], processor: 'builtin:assignment', config: { targetVariable: true }, assumePrimitive: true },
+    { type: 'function', names: ['assign', 'setGeneric', 'setValidity'], processor: 'builtin:assignment', config: { targetVariable: true, mayHaveMoreArgs: true }, assumePrimitive: true },
     { type: 'function', names: ['setMethod'], processor: 'builtin:assignment-like', config: { targetVariable: true, canBeReplacement: false, target: { idx: 0, name: 'f' }, source: { idx: 2, name: 'definition' } }, assumePrimitive: true },
     { type: 'function', names: ['delayedAssign'], processor: 'builtin:assignment', config: { quoteSource: true, targetVariable: true }, assumePrimitive: true },
     { type: 'function', names: ['<<-'], processor: 'builtin:assignment', config: { superAssignment: true, canBeReplacement: true }, assumePrimitive: true },

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];
@@ -41,10 +69,10 @@ function computeCallGraph(graph) {
         knownReachability: new defaultmap_1.DefaultMap(() => new Set())
     };
     for (const [, vert] of graph.vertices(false)) {
-        if (vert?.tag === vertex_1.VertexType.FunctionCall) {
+        if (vert.tag === vertex_1.VertexType.FunctionCall) {
             processCall(vert, undefined, graph, result, state);
         }
-        else if (vert?.tag === vertex_1.VertexType.FunctionDefinition) {
+        else if (vert.tag === vertex_1.VertexType.FunctionDefinition) {
             processFunctionDefinition(vert, undefined, graph, result, state);
         }
     }
@@ -74,6 +102,8 @@ function processCds(vtx, graph, result, state) {
         }
     }
 }
+const UntargetedCallFollow = edge_1.EdgeType.Reads | edge_1.EdgeType.DefinedByOnCall | edge_1.EdgeType.DefinedBy | edge_1.EdgeType.Returns;
+const UntargetedCallAvoid = edge_1.EdgeType.NonStandardEvaluation | edge_1.EdgeType.Argument;
 /**
  * This tracks the known symbol origins for a function call for which we know that flowr found no targets!
  */
@@ -94,7 +124,7 @@ function fallbackUntargetedCall(vtx, graph) {
         }
         let addedNew = false;
         for (const [tar, { types }] of graph.outgoingEdges(currentId) ?? []) {
-            if ((0, edge_1.edgeIncludesType)(types, edge_1.EdgeType.Reads | edge_1.EdgeType.DefinedByOnCall | edge_1.EdgeType.DefinedBy | edge_1.EdgeType.Returns) && (0, edge_1.edgeDoesNotIncludeType)(types, edge_1.EdgeType.NonStandardEvaluation | edge_1.EdgeType.Argument)) {
+            if ((0, edge_1.edgeIncludesType)(types, UntargetedCallFollow) && (0, edge_1.edgeDoesNotIncludeType)(types, UntargetedCallAvoid)) {
                 addedNew = true;
                 toVisit.push(tar);
             }
@@ -107,21 +137,22 @@ function fallbackUntargetedCall(vtx, graph) {
     return collected;
 }
 function processCall(vtx, from, graph, result, state) {
-    if (from && !reaches(from, vtx.id, result, state.knownReachability)) {
-        result.addEdge(from, vtx.id, edge_1.EdgeType.Calls);
+    const vid = vtx.id;
+    if (from && !reaches(from, vid, result, state.knownReachability)) {
+        result.addEdge(from, vid, edge_1.EdgeType.Calls);
     }
-    if (state.visited.has(vtx.id)) {
+    if (state.visited.has(vid)) {
         return;
     }
+    state.visited.add(vid);
     result.addVertex(vtx, undefined, true);
     processCds(vtx, graph, result, state);
-    state.visited.add(vtx.id);
     // for each call, resolve the targets
-    const tars = (0, linker_1.getAllFunctionCallTargets)(vtx.id, graph, vtx.environment);
+    const tars = (0, linker_1.getAllFunctionCallTargets)(vid, graph, vtx.environment);
     let addedTarget = false;
     for (const tar of tars) {
         if ((0, built_in_1.isBuiltIn)(tar)) {
-            result.addEdge(vtx.id, tar, edge_1.EdgeType.Calls);
+            result.addEdge(vid, tar, edge_1.EdgeType.Calls);
             addedTarget = true;
             continue;
         }
@@ -130,13 +161,13 @@ function processCall(vtx, from, graph, result, state) {
             continue;
         }
         addedTarget = true;
-        processFunctionDefinition(targetVtx, vtx.id, graph, result, state);
+        processFunctionDefinition(targetVtx, vid, graph, result, state);
     }
     if (vtx.origin !== 'unnamed') {
         for (const origs of vtx.origin) {
             if (origs.startsWith('builtin:')) {
                 addedTarget = true;
-                result.addEdge(vtx.id, (0, built_in_1.builtInId)(origs.substring('builtin:'.length)), edge_1.EdgeType.Calls);
+                result.addEdge(vid, (0, built_in_1.builtInId)(origs.substring('builtin:'.length)), edge_1.EdgeType.Calls);
             }
         }
     }
@@ -147,7 +178,7 @@ function processCall(vtx, from, graph, result, state) {
             if (!oriVtx) {
                 continue;
             }
-            result.addEdge(vtx.id, ori, edge_1.EdgeType.Calls);
+            result.addEdge(vid, ori, edge_1.EdgeType.Calls);
             const name = graph.idMap?.get(ori);
             if (name?.lexeme && oriVtx.tag === vertex_1.VertexType.Use) {
                 result.addVertex({
@@ -198,12 +229,12 @@ function processFunctionDefinition(vtx, from, graph, result, state) {
     result.addVertex(vtx, undefined, true);
     processCds(vtx, graph, result, state);
     const exits = new Set(vtx.exitPoints);
+    state.potentials.push([vtx.id, vtx.subflow.graph.difference(exits)]);
     for (const { nodeId } of exits) {
         const v = graph.getVertex(nodeId, true);
         if (v) {
             processUnknown(v, vtx.id, graph, result, state);
         }
     }
-    state.potentials.push([vtx.id, vtx.subflow.graph.difference(exits)]);
 }
 //# sourceMappingURL=call-graph.js.map

package/dataflow/internal/linker.js

@@ -34,33 +34,21 @@ function findNonLocalReads(graph, ignore) {
     const ids = new Set(graph.vertexIdsOfType(vertex_1.VertexType.Use).concat(graph.vertexIdsOfType(vertex_1.VertexType.FunctionCall)));
     /* find all variable use ids which do not link to a given id */
     const nonLocalReads = [];
-    for (const id of ids) {
-        if (ignores.has(id)) {
+    for (const nodeId of ids) {
+        if (ignores.has(nodeId)) {
             continue;
         }
-        const outgoing = graph.outgoingEdges(id);
-        const name = (0, node_id_1.recoverName)(id, graph.idMap);
-        const origin = graph.getVertex(id, true);
+        const outgoing = graph.outgoingEdges(nodeId);
+        const name = (0, node_id_1.recoverName)(nodeId, graph.idMap);
+        const origin = graph.getVertex(nodeId, true);
+        const type = origin?.tag === vertex_1.VertexType.FunctionCall ? identifier_1.ReferenceType.Function : identifier_1.ReferenceType.Variable;
         if (outgoing === undefined) {
-            nonLocalReads.push({
-                name: (0, node_id_1.recoverName)(id, graph.idMap),
-                nodeId: id,
-                controlDependencies: undefined,
-                type: origin?.tag === vertex_1.VertexType.FunctionCall ? identifier_1.ReferenceType.Function : identifier_1.ReferenceType.Variable
-            });
+            nonLocalReads.push({ name, nodeId, type });
             continue;
         }
         for (const [target, { types }] of outgoing) {
             if ((0, edge_1.edgeIncludesType)(types, edge_1.EdgeType.Reads) && !ids.has(target)) {
-                if (!name) {
-                    logger_1.dataflowLogger.warn('found non-local read without name for id ' + id);
-                }
-                nonLocalReads.push({
-                    name: (0, node_id_1.recoverName)(id, graph.idMap),
-                    nodeId: id,
-                    controlDependencies: undefined,
-                    type: origin?.tag === vertex_1.VertexType.FunctionCall ? identifier_1.ReferenceType.Function : identifier_1.ReferenceType.Variable
-                });
+                nonLocalReads.push({ name, nodeId, type });
                 break;
             }
         }

package/package.json

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

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,9 @@ 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)) {
+            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/inspect-higher-order-query/inspect-higher-order-query-executor.js

@@ -2,16 +2,41 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeHigherOrderQuery = executeHigherOrderQuery;
 const higher_order_function_1 = require("../../../dataflow/fn/higher-order-function");
-const inspect_exception_query_executor_1 = require("../inspect-exceptions-query/inspect-exception-query-executor");
+const parse_1 = require("../../../slicing/criterion/parse");
+const vertex_1 = require("../../../dataflow/graph/vertex");
 /**
  * Execute higher-order function inspection queries on the given analyzer.
  */
 async function executeHigherOrderQuery({ analyzer }, queries) {
     const start = Date.now();
-    const { cg, fns } = await (0, inspect_exception_query_executor_1.getFunctionsToConsiderInCallGraph)(queries, analyzer);
+    let filters = undefined;
+    // filter will remain undefined if at least one of the queries wants all functions
+    for (const q of queries) {
+        if (q.filter === undefined) {
+            filters = undefined;
+            break;
+        }
+        else {
+            filters ??= [];
+            filters = filters.concat(q.filter);
+        }
+    }
+    const ast = await analyzer.normalize();
+    const filterFor = new Set();
+    if (filters) {
+        for (const f of filters) {
+            const i = (0, parse_1.tryResolveSliceCriterionToId)(f, ast.idMap);
+            if (i !== undefined) {
+                filterFor.add(i);
+            }
+        }
+    }
+    const graph = (await analyzer.dataflow()).graph;
+    const fns = graph.verticesOfType(vertex_1.VertexType.FunctionDefinition)
+        .filter(([, v]) => filterFor.size === 0 || filterFor.has(v.id));
     const result = {};
     for (const [id,] of fns) {
-        result[id] = (0, higher_order_function_1.isFunctionHigherOrder)(id, cg, analyzer.inspectContext());
+        result[id] = (0, higher_order_function_1.isFunctionHigherOrder)(id, graph, analyzer.inspectContext());
     }
     return {
         '.meta': {

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/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.0';
+const version = '2.8.2';
 /**
  * Retrieves the current flowR version as a new {@link SemVer} object.
  */