@eagleoutice/flowr 2.8.1 → 2.8.2

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