@eagleoutice/flowr 2.0.8 → 2.0.10

package/benchmark/stats/print.js

@@ -10,6 +10,9 @@ function formatNanoseconds(nanoseconds) {
     if (nanoseconds < 0) {
         return '??';
     }
+    else if (!Number.isFinite(nanoseconds)) {
+        return nanoseconds > 0 ? '∞' : '-∞';
+    }
     const wholeNanos = typeof nanoseconds === 'bigint' ? nanoseconds : BigInt(Math.round(nanoseconds));
     const nanos = wholeNanos % BigInt(1e+6);
     const wholeMillis = wholeNanos / BigInt(1e+6);
@@ -145,7 +148,21 @@ Dataflow:
 }
 exports.stats2string = stats2string;
 function ultimateStats2String(stats) {
-    // Used Slice Criteria Sizes:  ${formatSummarizedMeasure(stats.perSliceMeasurements.sliceCriteriaSizes)}
+    const slice = stats.totalSlices > 0 ? `Slice summary for:
+  Total:                              ${formatSummarizedTimeMeasure(stats.perSliceMeasurements.get('total'))}
+  Slice creation:                     ${formatSummarizedTimeMeasure(stats.perSliceMeasurements.get('static slicing'))}
+  Slice creation per token in slice:  ${formatSummarizedTimeMeasure(stats.sliceTimePerToken.normalized)}
+  Slice creation per R token in slice:${formatSummarizedTimeMeasure(stats.sliceTimePerToken.raw)}
+  Reconstruction:                     ${formatSummarizedTimeMeasure(stats.perSliceMeasurements.get('reconstruct code'))}
+  Reconstruction per token in slice:  ${formatSummarizedTimeMeasure(stats.reconstructTimePerToken.normalized)}
+  Reconstruction per R token in slice:${formatSummarizedTimeMeasure(stats.reconstructTimePerToken.raw)}
+  Total per token in slice:           ${formatSummarizedTimeMeasure(stats.totalPerSliceTimePerToken.normalized)}
+  Total per R token in slice:         ${formatSummarizedTimeMeasure(stats.totalPerSliceTimePerToken.raw)}
+  Failed to Re-Parse:                 ${pad(stats.failedToRepParse)}/${stats.totalSlices}
+  Times hit Threshold:                ${pad(stats.timesHitThreshold)}/${stats.totalSlices} 
+${reduction2String('Reductions', stats.reduction)}
+${reduction2String('Reductions without comments and empty lines', stats.reductionNoFluff)}` : 'No slices';
+    // Used Slice Criteria Sizes: ${formatSummarizedMeasure(stats.perSliceMeasurements.sliceCriteriaSizes)}
     return `
 Summarized: ${stats.totalRequests} requests and ${stats.totalSlices} slices
 Shell init time:              ${formatSummarizedTimeMeasure(stats.commonMeasurements.get('initialize R session'))}
@@ -161,20 +178,7 @@ Dataflow creation per R token:${formatSummarizedTimeMeasure(stats.dataflowTimePe
 Total common time per token:  ${formatSummarizedTimeMeasure(stats.totalCommonTimePerToken.normalized)}
 Total common time per R token:${formatSummarizedTimeMeasure(stats.totalCommonTimePerToken.raw)}
 
-Slice summary for:
-  Total:                              ${formatSummarizedTimeMeasure(stats.perSliceMeasurements.get('total'))}
-  Slice creation:                     ${formatSummarizedTimeMeasure(stats.perSliceMeasurements.get('static slicing'))}
-  Slice creation per token in slice:  ${formatSummarizedTimeMeasure(stats.sliceTimePerToken.normalized)}
-  Slice creation per R token in slice:${formatSummarizedTimeMeasure(stats.sliceTimePerToken.raw)}
-  Reconstruction:                     ${formatSummarizedTimeMeasure(stats.perSliceMeasurements.get('reconstruct code'))}
-  Reconstruction per token in slice:  ${formatSummarizedTimeMeasure(stats.reconstructTimePerToken.normalized)}
-  Reconstruction per R token in slice:${formatSummarizedTimeMeasure(stats.reconstructTimePerToken.raw)}
-  Total per token in slice:           ${formatSummarizedTimeMeasure(stats.totalPerSliceTimePerToken.normalized)}
-  Total per R token in slice:         ${formatSummarizedTimeMeasure(stats.totalPerSliceTimePerToken.raw)}
-  Failed to Re-Parse:                 ${pad(stats.failedToRepParse)}/${stats.totalSlices}
-  Times hit Threshold:                ${pad(stats.timesHitThreshold)}/${stats.totalSlices} 
-${reduction2String('Reductions', stats.reduction)}
-${reduction2String('Reductions without comments and empty lines', stats.reductionNoFluff)}
+${slice}
 
 Shell close:                  ${formatSummarizedTimeMeasure(stats.commonMeasurements.get('close R session'))}
 Total:                        ${formatSummarizedTimeMeasure(stats.commonMeasurements.get('total'))}

package/benchmark/summarizer/summarizer.js

@@ -21,20 +21,21 @@ class BenchmarkSummarizer extends summarizer_1.Summarizer {
     async preparationPhase() {
         this.removeIfExists(this.summaryFile());
         this.removeIfExists(this.config.intermediateOutputPath);
-        fs_1.default.mkdirSync(this.config.intermediateOutputPath);
-        const filesToSummarize = fs_1.default.readdirSync(this.config.inputPath);
+        fs_1.default.mkdirSync(this.config.intermediateOutputPath, { recursive: true });
+        let fileNum = 0;
         const outputPathsPerRun = new defaultmap_1.DefaultMap(() => []);
-        for (let i = 0; i < filesToSummarize.length; i++) {
-            const fileInputPath = path_1.default.join(this.config.inputPath, filesToSummarize[i]);
-            const outputDir = path_1.default.join(this.config.intermediateOutputPath, path_1.default.parse(filesToSummarize[i]).name);
-            fs_1.default.mkdirSync(outputDir);
+        // recursively find all files in all the input path subdirectories
+        for await (const file of (0, files_1.getAllFiles)(this.config.inputPath)) {
+            const outputDir = path_1.default.join(this.config.intermediateOutputPath, path_1.default.relative(this.config.inputPath, file));
+            fs_1.default.mkdirSync(outputDir, { recursive: true });
             const textOutputPath = path_1.default.join(outputDir, 'summary.log');
             // generate measurements for each run
-            await (0, files_1.readLineByLine)(fileInputPath, (line, lineNumber) => {
+            await (0, files_1.readLineByLine)(file, (line, lineNumber) => {
                 const runOutputPath = path_1.default.join(outputDir, `run-${lineNumber}.json`);
                 outputPathsPerRun.get(lineNumber).push(runOutputPath);
-                return (0, input_1.processRunMeasurement)(line, i, lineNumber, textOutputPath, runOutputPath);
+                return (0, input_1.processRunMeasurement)(line, fileNum, lineNumber, textOutputPath, runOutputPath);
             });
+            fileNum++;
         }
         // generate combined measurements for each file per run
         for (const [run, paths] of outputPathsPerRun.entries()) {

package/cli/benchmark-app.js

@@ -32,13 +32,15 @@ function removeIfExists(summarizedRaw) {
 }
 async function benchmark() {
     removeIfExists(options.output);
-    fs_1.default.mkdirSync(options.output);
+    fs_1.default.mkdirSync(options.output, { recursive: true });
     console.log(`Storing output in ${options.output}`);
     console.log(`Using ${options.parallel} parallel executors`);
     // we do not use the limit argument to be able to pick the limit randomly
     const files = [];
-    for await (const file of (0, files_1.allRFilesFrom)(options.input)) {
-        files.push(file);
+    for (const input of options.input) {
+        for await (const file of (0, files_1.allRFiles)(input)) {
+            files.push({ request: file, baseDir: input });
+        }
     }
     if (options.limit) {
         log_1.log.info(`limiting to ${options.limit} files`);
@@ -48,9 +50,9 @@ async function benchmark() {
     const limit = options.limit ?? files.length;
     const verboseAdd = options.verbose ? ['--verbose'] : [];
     const args = files.map((f, i) => [
-        '--input', f.content,
+        '--input', f.request.content,
         '--file-id', `${i}`,
-        '--output', path_1.default.join(options.output, `${path_1.default.parse(f.content).name}.json`),
+        '--output', path_1.default.join(options.output, path_1.default.relative(f.baseDir, `${f.request.content}.json`)),
         '--slice', options.slice, ...verboseAdd
     ]);
     const runs = options.runs ?? 1;

package/cli/benchmark-helper-app.js

@@ -10,6 +10,7 @@ const json_1 = require("../util/json");
 const script_1 = require("./common/script");
 const slicer_1 = require("../benchmark/slicer");
 const all_variables_1 = require("../slicing/criterion/filters/all-variables");
+const path_1 = __importDefault(require("path"));
 const options = (0, script_1.processCommandLineArgs)('benchmark-helper', [], {
     subtitle: 'Will slice for all possible variables, signal by exit code if slicing was successful, and can be run standalone',
     examples: [
@@ -30,6 +31,7 @@ async function benchmark() {
     // prefix for printing to console, includes file id and run number if present
     const prefix = `[${options.input}${options['file-id'] !== undefined ? ` (file ${options['file-id']}, run ${options['run-num']})` : ''}]`;
     console.log(`${prefix} Appending output to ${options.output}`);
+    fs_1.default.mkdirSync(path_1.default.parse(options.output).dir, { recursive: true });
     // ensure the file exists
     const fileStat = fs_1.default.statSync(options.input);
     (0, assert_1.guard)(fileStat.isFile(), `File ${options.input} does not exist or is no file`);
@@ -61,6 +63,7 @@ async function benchmark() {
             stats
         };
         // append line by line
+        console.log(`Appending benchmark of ${options.input} to ${options.output}`);
         fs_1.default.appendFileSync(options.output, `${JSON.stringify(output, json_1.jsonReplacer)}\n`);
     }
     catch (e) {

package/cli/repl/server/connection.d.ts

@@ -1,5 +1,8 @@
 import type { Socket } from './net';
+import { DEFAULT_SLICING_PIPELINE } from '../../../core/steps/pipeline/default-pipelines';
 import type { RShell } from '../../../r-bridge/shell';
+import type { PipelineOutput } from '../../../core/steps/pipeline/pipeline';
+import type { DeepPartial } from 'ts-essentials';
 /**
  * Each connection handles a single client, answering to its requests.
  * There is no need to construct this class manually, {@link FlowRServer} will do it for you.
@@ -19,3 +22,4 @@ export declare class FlowRServerConnection {
     private handleSliceRequest;
     private handleRepl;
 }
+export declare function sanitizeAnalysisResults(results: Partial<PipelineOutput<typeof DEFAULT_SLICING_PIPELINE>>): DeepPartial<PipelineOutput<typeof DEFAULT_SLICING_PIPELINE>>;

package/cli/repl/server/connection.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FlowRServerConnection = void 0;
+exports.sanitizeAnalysisResults = exports.FlowRServerConnection = void 0;
 const send_1 = require("./send");
 const validate_1 = require("./validate");
 const analysis_1 = require("./messages/analysis");
@@ -103,6 +103,7 @@ class FlowRServerConnection {
             cfg = (0, cfg_1.extractCFG)(results.normalize);
         }
         const config = () => ({ context: message.filename ?? 'unknown', getId: (0, quads_1.defaultQuadIdGenerator)() });
+        const sanitizedResults = sanitizeAnalysisResults(results);
         if (message.format === 'n-quads') {
             (0, send_1.sendMessage)(this.socket, {
                 type: 'response-file-analysis',
@@ -110,9 +111,9 @@ class FlowRServerConnection {
                 id: message.id,
                 cfg: cfg ? (0, cfg_1.cfg2quads)(cfg, config()) : undefined,
                 results: {
-                    parse: await (0, print_1.printStepResult)(_00_parse_1.PARSE_WITH_R_SHELL_STEP, results.parse, 5 /* StepOutputFormat.RdfQuads */, config()),
-                    normalize: await (0, print_1.printStepResult)(_10_normalize_1.NORMALIZE, results.normalize, 5 /* StepOutputFormat.RdfQuads */, config()),
-                    dataflow: await (0, print_1.printStepResult)(_20_dataflow_1.STATIC_DATAFLOW, results.dataflow, 5 /* StepOutputFormat.RdfQuads */, config())
+                    parse: await (0, print_1.printStepResult)(_00_parse_1.PARSE_WITH_R_SHELL_STEP, sanitizedResults.parse, 5 /* StepOutputFormat.RdfQuads */, config()),
+                    normalize: await (0, print_1.printStepResult)(_10_normalize_1.NORMALIZE, sanitizedResults.normalize, 5 /* StepOutputFormat.RdfQuads */, config()),
+                    dataflow: await (0, print_1.printStepResult)(_20_dataflow_1.STATIC_DATAFLOW, sanitizedResults.dataflow, 5 /* StepOutputFormat.RdfQuads */, config())
                 }
             });
         }
@@ -122,13 +123,7 @@ class FlowRServerConnection {
                 format: 'json',
                 id: message.id,
                 cfg,
-                results: {
-                    ...results,
-                    normalize: {
-                        ...results.normalize,
-                        idMap: undefined
-                    }
-                }
+                results: sanitizedResults
             });
         }
     }
@@ -215,4 +210,23 @@ class FlowRServerConnection {
     }
 }
 exports.FlowRServerConnection = FlowRServerConnection;
+function sanitizeAnalysisResults(results) {
+    return {
+        ...results,
+        normalize: {
+            ...results.normalize,
+            idMap: undefined
+        },
+        dataflow: {
+            ...results.dataflow,
+            graph: {
+                ...results.dataflow?.graph,
+                functionCache: undefined,
+                // @ts-expect-error this is private, but we want to sanitize it for the purpose of json serialization
+                _idMap: undefined
+            }
+        }
+    };
+}
+exports.sanitizeAnalysisResults = sanitizeAnalysisResults;
 //# sourceMappingURL=connection.js.map

package/dataflow/environments/environment.d.ts

@@ -12,7 +12,7 @@ export declare function makeAllMaybe(references: readonly IdentifierReference[]
 export type EnvironmentMemory = Map<Identifier, IdentifierDefinition[]>;
 export interface IEnvironment {
     /** unique and internally generated identifier -- will not be used for comparison but assists debugging for tracking identities */
-    readonly id: string;
+    readonly id: number;
     /** Lexical parent of the environment, if any (can be manipulated by R code) */
     parent: IEnvironment;
     /**
@@ -21,7 +21,7 @@ export interface IEnvironment {
     memory: EnvironmentMemory;
 }
 export declare class Environment implements IEnvironment {
-    readonly id: string;
+    readonly id: number;
     parent: IEnvironment;
     memory: Map<Identifier, IdentifierDefinition[]>;
     constructor(parent: IEnvironment);

package/dataflow/environments/environment.js

@@ -39,7 +39,7 @@ function makeAllMaybe(references, graph, environments, includeDefs, defaultCd =
 exports.makeAllMaybe = makeAllMaybe;
 let environmentIdCounter = 0;
 class Environment {
-    id = `${environmentIdCounter++}`;
+    id = environmentIdCounter++;
     parent;
     memory;
     constructor(parent) {

package/package.json

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

package/util/mermaid/dfg.js

@@ -57,11 +57,11 @@ function printArg(arg) {
         return '[empty]';
     }
     else if ((0, graph_1.isNamedArgument)(arg)) {
-        const deps = arg.controlDependencies ? ', :maybe:' + arg.controlDependencies.map(c => c.id + (c.when ? '+' : '-')).join(',') : '';
+        const deps = arg.controlDependencies ? ', :may:' + arg.controlDependencies.map(c => c.id + (c.when ? '+' : '-')).join(',') : '';
         return `${arg.name} (${arg.nodeId}${deps})`;
     }
     else if ((0, graph_1.isPositionalArgument)(arg)) {
-        const deps = arg.controlDependencies ? ' (:maybe:' + arg.controlDependencies.map(c => c.id + (c.when ? '+' : '-')).join(',') + ')' : '';
+        const deps = arg.controlDependencies ? ' (:may:' + arg.controlDependencies.map(c => c.id + (c.when ? '+' : '-')).join(',') + ')' : '';
         return `${arg.nodeId}${deps}`;
     }
     else {
@@ -128,7 +128,7 @@ function vertexToMermaid(info, mermaid, id, idPrefix, mark) {
     const node = mermaid.rootGraph.idMap?.get(info.id);
     const lexeme = node?.lexeme ?? (node?.type === "RExpressionList" /* RType.ExpressionList */ ? node?.grouping?.[0]?.lexeme : '') ?? '??';
     const escapedName = (0, mermaid_1.escapeMarkdown)(node ? `[${node.type}] ${lexeme}` : '??');
-    const deps = info.controlDependencies ? ', :maybe:' + info.controlDependencies.join(',') : '';
+    const deps = info.controlDependencies ? ', :may:' + info.controlDependencies.map(c => c.id + (c.when ? '+' : '-')).join(',') : '';
     const n = node?.info.fullRange ?? node?.location ?? (node?.type === "RExpressionList" /* RType.ExpressionList */ ? node?.grouping?.[0].location : undefined);
     mermaid.nodeLines.push(`    ${idPrefix}${id}${open}"\`${escapedName}${escapedName.length > 10 ? '\n      ' : ' '}(${id}${deps})\n      *${formatRange(n)}*${fCall ? displayFunctionArgMapping(info.args) : ''}\`"${close}`);
     if (mark?.has(id)) {

package/util/mermaid/mermaid.js

@@ -16,7 +16,8 @@ const replacements = {
     '\\': '#92;',
     '_': '#95;',
     '{': '#123;',
-    '}': '#125;'
+    '}': '#125;',
+    '&': '#38;'
 };
 function escapeMarkdown(text) {
     for (const [key, value] of Object.entries(replacements)) {

package/util/version.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.flowrVersion = void 0;
 const semver_1 = require("semver");
 // this is automatically replaced with the current version by release-it
-const version = '2.0.8';
+const version = '2.0.10';
 function flowrVersion() {
     return new semver_1.SemVer(version);
 }