@eagleoutice/flowr 2.0.14 → 2.0.15

package/benchmark/slicer.d.ts

@@ -11,6 +11,7 @@ import type { NormalizedAst } from '../r-bridge/lang-4.x/ast/model/processing/de
 import type { SlicingCriteria } from '../slicing/criterion/parse';
 import type { RParseRequestFromFile, RParseRequestFromText } from '../r-bridge/retriever';
 import type { SlicingCriteriaFilter } from '../slicing/criterion/collect-all';
+import type { AutoSelectPredicate } from '../reconstruct/auto-select/auto-select-defaults';
 /**
  * The logger to be used for benchmarking as a global object.
  */
@@ -68,7 +69,7 @@ export declare class BenchmarkSlicer {
      * Initialize the slicer on the given request.
      * Can only be called once for each instance.
      */
-    init(request: RParseRequestFromFile | RParseRequestFromText): Promise<void>;
+    init(request: RParseRequestFromFile | RParseRequestFromText, autoSelectIf?: AutoSelectPredicate): Promise<void>;
     private calculateStatsAfterInit;
     /**
    * Slice for the given {@link SlicingCriteria}.

package/benchmark/slicer.js

@@ -55,12 +55,13 @@ class BenchmarkSlicer {
      * Initialize the slicer on the given request.
      * Can only be called once for each instance.
      */
-    async init(request) {
+    async init(request, autoSelectIf) {
         (0, assert_1.guard)(this.stats === undefined, 'cannot initialize the slicer twice');
         this.pipeline = new pipeline_executor_1.PipelineExecutor(default_pipelines_1.DEFAULT_SLICING_PIPELINE, {
             shell: this.shell,
             request: { ...request },
-            criterion: []
+            criterion: [],
+            autoSelectIf
         });
         this.loadedXml = await this.measureCommonStep('parse', 'retrieve AST from R code');
         this.normalizedAst = await this.measureCommonStep('normalize', 'normalize R AST');

package/cli/common/options.js

@@ -46,6 +46,7 @@ exports.slicerOptions = [
     { name: 'criterion', alias: 'c', type: String, description: '(Required) Slicing criterion either in the form {underline line:col} or {underline line@variable}, multiple can be separated by \'{bold ;}\'. If you do not want to slice but only process the file, pass an empty string.', multiple: false },
     { name: 'stats', alias: 's', type: Boolean, description: 'Print stats and write them to {italic <output>.stats} (runtimes etc.)', multiple: false },
     { name: 'output', alias: 'o', type: String, description: 'File to write all the generated quads to (defaults to the commandline)', typeLabel: '{underline file}' },
+    { name: 'no-magic-comments', alias: 'm', type: Boolean, description: 'Disable the effects of magic comments which force lines to be included.' },
     { name: 'api', type: Boolean, description: 'Instead of human-readable output, dump a lot of json with the results of all intermediate steps.' },
 ];
 const featureNameList = [...feature_1.allFeatureNames].map(s => `"${s}"`).join(', ');

package/cli/flowr.js

@@ -87,10 +87,9 @@ function retrieveShell() {
 }
 async function mainRepl() {
     if (options.script) {
-        let target = scripts_info_1.scripts[options.script].target;
+        const target = scripts_info_1.scripts[options.script].target;
         (0, assert_1.guard)(target !== undefined, `Unknown script ${options.script}, pick one of ${getScriptsText()}.`);
         console.log(`Running script '${ansi_1.formatter.format(options.script, { style: 1 /* FontStyles.Bold */ })}'`);
-        target = `cli/${target}`;
         log_1.log.debug(`Script maps to "${target}"`);
         await (0, execute_1.waitOnScript)(`${__dirname}/${target}`, process.argv.slice(3), undefined, true);
         process.exit(0);

package/cli/repl/commands/commands.js

@@ -30,7 +30,7 @@ exports.helpCommand = {
     fn: output => {
         initCommandMapping();
         output.stdout(`
-You can always just enter R expressions which get evaluated right away:
+If enabled, you can just enter R expressions which get evaluated right away:
 ${prompt_1.rawPrompt} ${(0, ansi_1.bold)('1 + 1', output.formatter)}
 ${(0, ansi_1.italic)('[1] 2', output.formatter)}
 

package/cli/repl/core.js

@@ -115,7 +115,7 @@ async function replProcessStatement(output, statement, shell, allowRSessionAcces
         await (0, execute_1.executeRShellCommand)(output, shell, statement);
     }
     else {
-        output.stderr(`${output.formatter.format('You are not allowed to execute arbitrary R code.', { style: 1 /* FontStyles.Bold */, color: 1 /* Colors.Red */, effect: ansi_1.ColorEffect.Foreground })}\nIf you want to do so, please restart flowR with the ${output.formatter.format('--r-session-access', { style: 1 /* FontStyles.Bold */ })}  flag. Please be careful of the security implications of this action.`);
+        output.stderr(`${output.formatter.format('You are not allowed to execute arbitrary R code.', { style: 1 /* FontStyles.Bold */, color: 1 /* Colors.Red */, effect: ansi_1.ColorEffect.Foreground })}\nIf you want to do so, please restart flowR with the ${output.formatter.format('--r-session-access', { style: 1 /* FontStyles.Bold */ })} flag. Please be careful of the security implications of this action.`);
     }
 }
 /**

package/cli/repl/server/connection.js

@@ -46,6 +46,8 @@ const default_pipelines_1 = require("../../../core/steps/pipeline/default-pipeli
 const graph_1 = require("../../../dataflow/graph/graph");
 const tmp = __importStar(require("tmp"));
 const fs_1 = __importDefault(require("fs"));
+const auto_select_defaults_1 = require("../../../reconstruct/auto-select/auto-select-defaults");
+const magic_comments_1 = require("../../../reconstruct/auto-select/magic-comments");
 /**
  * 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.
@@ -211,7 +213,10 @@ class FlowRServerConnection {
             });
             return;
         }
-        fileInformation.pipeline.updateRequest({ criterion: request.criterion });
+        fileInformation.pipeline.updateRequest({
+            criterion: request.criterion,
+            autoSelectIf: request.noMagicComments ? auto_select_defaults_1.autoSelectLibrary : (0, magic_comments_1.makeMagicCommentHandler)(auto_select_defaults_1.autoSelectLibrary)
+        });
         void fileInformation.pipeline.allRemainingSteps(true).then(results => {
             (0, send_1.sendMessage)(this.socket, {
                 type: 'response-slice',

package/cli/repl/server/messages/slice.d.ts

@@ -13,6 +13,10 @@ export interface SliceRequestMessage extends IdMessageBase {
     filetoken: string;
     /** The slicing criteria to use */
     criterion: SlicingCriteria;
+    /**
+     * Should the magic comments (force-including lines within the slice) be ignord?
+     */
+    noMagicComments?: boolean;
 }
 export declare const requestSliceMessage: MessageDefinition<SliceRequestMessage>;
 /**

package/cli/repl/server/messages/slice.js

@@ -31,7 +31,7 @@ exports.requestSliceMessage = {
         type: Joi.string().valid('request-slice').required(),
         id: Joi.string().optional(),
         filetoken: Joi.string().required(),
-        criterion: Joi.array().items(Joi.string().regex(/\d+:\d+|\d+@.*|\$\d+/)).min(0).required()
+        criterion: Joi.array().items(Joi.string()).min(0).required()
     })
 };
 //# sourceMappingURL=slice.js.map

package/cli/slicer-app.d.ts

@@ -8,4 +8,5 @@ export interface SlicerCliOptions {
     'input-is-text': boolean;
     stats: boolean;
     api: boolean;
+    'no-magic-comments': boolean;
 }

package/cli/slicer-app.js

@@ -12,6 +12,8 @@ const json_1 = require("../util/json");
 const script_1 = require("./common/script");
 const slicer_1 = require("../benchmark/slicer");
 const print_1 = require("../benchmark/stats/print");
+const auto_select_defaults_1 = require("../reconstruct/auto-select/auto-select-defaults");
+const magic_comments_1 = require("../reconstruct/auto-select/magic-comments");
 const options = (0, script_1.processCommandLineArgs)('slicer', ['input', 'criterion'], {
     subtitle: 'Slice R code based on a given slicing criterion',
     examples: [
@@ -26,7 +28,9 @@ async function getSlice() {
     const slicer = new slicer_1.BenchmarkSlicer();
     (0, assert_1.guard)(options.input !== undefined, 'input must be given');
     (0, assert_1.guard)(options.criterion !== undefined, 'a slicing criterion must be given');
-    await slicer.init(options['input-is-text'] ? { request: 'text', content: options.input } : { request: 'file', content: options.input });
+    await slicer.init(options['input-is-text']
+        ? { request: 'text', content: options.input }
+        : { request: 'file', content: options.input }, options['no-magic-comments'] ? auto_select_defaults_1.autoSelectLibrary : (0, magic_comments_1.makeMagicCommentHandler)(auto_select_defaults_1.autoSelectLibrary));
     let mappedSlices = [];
     let reconstruct = undefined;
     const doSlicing = options.criterion.trim() !== '';

package/core/steps/all/static-slicing/10-reconstruct.d.ts

@@ -1,8 +1,8 @@
 import { internalPrinter } from '../../../print/print';
 import { PipelineStepStage } from '../../pipeline-step';
 import type { SliceResult } from '../../../../slicing/static/slicer-types';
-import type { AutoSelectPredicate } from '../../../../reconstruct/reconstruct';
 import type { NormalizedAst } from '../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { AutoSelectPredicate } from '../../../../reconstruct/auto-select/auto-select-defaults';
 export interface ReconstructRequiredInput {
     autoSelectIf?: AutoSelectPredicate;
 }

package/core/steps/pipeline/default-pipelines.d.ts

@@ -76,7 +76,7 @@ export declare const DEFAULT_SLICING_PIPELINE: import("./pipeline").Pipeline<{
     readonly dependencies: readonly ["slice"];
     readonly requiredInput: import("../all/static-slicing/10-reconstruct").ReconstructRequiredInput;
 }>;
-export declare const DEFAULT_RECONSTRUCT_PIPELINE: import("./pipeline").Pipeline<{
+export declare const DEFAULT_SLICE_AND_RECONSTRUCT_PIPELINE: import("./pipeline").Pipeline<{
     readonly name: "parse";
     readonly humanReadableName: "parse with R shell";
     readonly description: "Parse the given R code into an AST";

package/core/steps/pipeline/default-pipelines.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_PARSE_PIPELINE = exports.DEFAULT_NORMALIZE_PIPELINE = exports.DEFAULT_DATAFLOW_PIPELINE = exports.DEFAULT_RECONSTRUCT_PIPELINE = exports.DEFAULT_SLICING_PIPELINE = void 0;
+exports.DEFAULT_PARSE_PIPELINE = exports.DEFAULT_NORMALIZE_PIPELINE = exports.DEFAULT_DATAFLOW_PIPELINE = exports.DEFAULT_SLICE_AND_RECONSTRUCT_PIPELINE = exports.DEFAULT_SLICING_PIPELINE = void 0;
 /**
  * Contains the default pipeline for working with flowr
  */
@@ -11,7 +11,7 @@ const _20_dataflow_1 = require("../all/core/20-dataflow");
 const _00_slice_1 = require("../all/static-slicing/00-slice");
 const _10_reconstruct_1 = require("../all/static-slicing/10-reconstruct");
 exports.DEFAULT_SLICING_PIPELINE = (0, pipeline_1.createPipeline)(_00_parse_1.PARSE_WITH_R_SHELL_STEP, _10_normalize_1.NORMALIZE, _20_dataflow_1.STATIC_DATAFLOW, _00_slice_1.STATIC_SLICE, _10_reconstruct_1.NAIVE_RECONSTRUCT);
-exports.DEFAULT_RECONSTRUCT_PIPELINE = exports.DEFAULT_SLICING_PIPELINE;
+exports.DEFAULT_SLICE_AND_RECONSTRUCT_PIPELINE = exports.DEFAULT_SLICING_PIPELINE;
 exports.DEFAULT_DATAFLOW_PIPELINE = (0, pipeline_1.createPipeline)(_00_parse_1.PARSE_WITH_R_SHELL_STEP, _10_normalize_1.NORMALIZE, _20_dataflow_1.STATIC_DATAFLOW);
 exports.DEFAULT_NORMALIZE_PIPELINE = (0, pipeline_1.createPipeline)(_00_parse_1.PARSE_WITH_R_SHELL_STEP, _10_normalize_1.NORMALIZE);
 exports.DEFAULT_PARSE_PIPELINE = (0, pipeline_1.createPipeline)(_00_parse_1.PARSE_WITH_R_SHELL_STEP);

package/dataflow/graph/diff.d.ts

@@ -1,5 +1,5 @@
 import type { DataflowGraph, FunctionArgument, OutgoingEdges } from './graph';
-import type { GenericDifferenceInformation, WriteableDifferenceReport } from '../../util/diff';
+import type { GenericDiffConfiguration, GenericDifferenceInformation, WriteableDifferenceReport } from '../../util/diff';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 interface ProblematicVertex {
     tag: 'vertex';
@@ -14,7 +14,7 @@ export type ProblematicDiffInfo = ProblematicVertex | ProblematicEdge;
 export declare class DataflowDifferenceReport implements WriteableDifferenceReport {
     _comments: string[] | undefined;
     _problematic: ProblematicDiffInfo[] | undefined;
-    addComment(comment: string, ...related: ProblematicDiffInfo[]): void;
+    addComment(comment: string, ...related: readonly ProblematicDiffInfo[]): void;
     comments(): readonly string[] | undefined;
     problematic(): readonly ProblematicDiffInfo[] | undefined;
     isEqual(): boolean;
@@ -26,8 +26,9 @@ export interface NamedGraph {
 interface DataflowDiffContext extends GenericDifferenceInformation<DataflowDifferenceReport> {
     left: DataflowGraph;
     right: DataflowGraph;
+    config: GenericDiffConfiguration;
 }
-export declare function diffOfDataflowGraphs(left: NamedGraph, right: NamedGraph): DataflowDifferenceReport;
+export declare function diffOfDataflowGraphs(left: NamedGraph, right: NamedGraph, config?: Partial<GenericDiffConfiguration>): DataflowDifferenceReport;
 export declare function equalFunctionArguments(fn: NodeId, a: false | readonly FunctionArgument[], b: false | readonly FunctionArgument[]): boolean;
 export declare function diffFunctionArguments(fn: NodeId, a: false | readonly FunctionArgument[], b: false | readonly FunctionArgument[], ctx: GenericDifferenceInformation<DataflowDifferenceReport>): void;
 export declare function diffVertices(ctx: DataflowDiffContext): void;

package/dataflow/graph/diff.js

@@ -40,31 +40,40 @@ class DataflowDifferenceReport {
     }
 }
 exports.DataflowDifferenceReport = DataflowDifferenceReport;
-function initDiffContext(left, right) {
+function initDiffContext(left, right, config) {
     return {
         left: left.graph,
         leftname: left.name,
         right: right.graph,
         rightname: right.name,
         report: new DataflowDifferenceReport(),
-        position: ''
+        position: '',
+        config: {
+            rightIsSubgraph: false,
+            leftIsSubgraph: false,
+            ...config
+        }
     };
 }
 function diff(ctx) {
     diffRootVertices(ctx);
     diffVertices(ctx);
     diffOutgoingEdges(ctx);
-    return true;
 }
 function diffOutgoingEdges(ctx) {
     const lEdges = new Map([...ctx.left.edges()]);
     const rEdges = new Map([...ctx.right.edges()]);
-    if (lEdges.size !== rEdges.size) {
+    if (lEdges.size < rEdges.size && !ctx.config.leftIsSubgraph || lEdges.size > rEdges.size && !ctx.config.rightIsSubgraph) {
         ctx.report.addComment(`Detected different number of edges! ${ctx.leftname} has ${lEdges.size} (${JSON.stringify(lEdges, json_1.jsonReplacer)}). ${ctx.rightname} has ${rEdges.size} ${JSON.stringify(rEdges, json_1.jsonReplacer)}`);
     }
     for (const [id, edge] of lEdges) {
+        /* This has nothing to do with the subset relation as we verify this in the same graph.
+         * Yet we still do the check as a subgraph may not have to have all source vertices for edges.
+         */
         if (!ctx.left.hasVertex(id)) {
-            ctx.report.addComment(`The source ${id} of edges ${JSON.stringify(edge, json_1.jsonReplacer)} is not present in ${ctx.leftname}. This means that the graph contains an edge but not the corresponding vertex.`);
+            if (!ctx.config.leftIsSubgraph) {
+                ctx.report.addComment(`The source ${id} of edges ${JSON.stringify(edge, json_1.jsonReplacer)} is not present in ${ctx.leftname}. This means that the graph contains an edge but not the corresponding vertex.`);
+            }
             continue;
         }
         diffEdges(ctx, id, edge, rEdges.get(id));
@@ -72,22 +81,25 @@ function diffOutgoingEdges(ctx) {
     // just to make it both ways in case the length differs
     for (const [id, edge] of rEdges) {
         if (!ctx.right.hasVertex(id)) {
-            ctx.report.addComment(`The source ${id} of edges ${JSON.stringify(edge, json_1.jsonReplacer)} is not present in ${ctx.rightname}. This means that the graph contains an edge but not the corresponding vertex.`);
+            if (!ctx.config.rightIsSubgraph) {
+                ctx.report.addComment(`The source ${id} of edges ${JSON.stringify(edge, json_1.jsonReplacer)} is not present in ${ctx.rightname}. This means that the graph contains an edge but not the corresponding vertex.`);
+            }
             continue;
         }
-        if (!lEdges.has(id)) {
+        if (!ctx.config.leftIsSubgraph && !lEdges.has(id)) {
             diffEdges(ctx, id, undefined, edge);
         }
+        /* otherwise, we already cover the edge above */
     }
 }
 function diffRootVertices(ctx) {
     (0, diff_1.setDifference)(ctx.left.rootIds(), ctx.right.rootIds(), { ...ctx, position: `${ctx.position}Root vertices differ in graphs. ` });
 }
-function diffOfDataflowGraphs(left, right) {
+function diffOfDataflowGraphs(left, right, config) {
     if (left.graph === right.graph) {
         return new DataflowDifferenceReport();
     }
-    const ctx = initDiffContext(left, right);
+    const ctx = initDiffContext(left, right, config);
     diff(ctx);
     return ctx.report;
 }
@@ -106,7 +118,8 @@ function equalFunctionArguments(fn, a, b) {
         report: new DataflowDifferenceReport(),
         leftname: 'left',
         rightname: 'right',
-        position: ''
+        position: '',
+        config: {}
     };
     diffFunctionArguments(fn, a, b, ctx);
     return ctx.report.isEqual();
@@ -155,13 +168,16 @@ function diffVertices(ctx) {
     // collect vertices from both sides
     const lVert = [...ctx.left.vertices(true)].map(([id, info]) => [id, info]);
     const rVert = [...ctx.right.vertices(true)].map(([id, info]) => [id, info]);
-    if (lVert.length !== rVert.length) {
+    if (lVert.length < rVert.length && !ctx.config.leftIsSubgraph
+        || lVert.length > rVert.length && !ctx.config.rightIsSubgraph) {
         ctx.report.addComment(`Detected different number of vertices! ${ctx.leftname} has ${lVert.length}, ${ctx.rightname} has ${rVert.length}`);
     }
     for (const [id, lInfo] of lVert) {
         const rInfoMay = ctx.right.get(id);
         if (rInfoMay === undefined) {
-            ctx.report.addComment(`Vertex ${id} is not present in ${ctx.rightname}`, { tag: 'vertex', id });
+            if (!ctx.config.rightIsSubgraph) {
+                ctx.report.addComment(`Vertex ${id} is not present in ${ctx.rightname}`, { tag: 'vertex', id });
+            }
             continue;
         }
         const [rInfo] = rInfoMay;
@@ -173,15 +189,21 @@ function diffVertices(ctx) {
             const lname = lInfo.name ?? (0, node_id_1.recoverName)(id, ctx.left.idMap) ?? '??';
             const rname = rInfo.name ?? (0, node_id_1.recoverName)(id, ctx.right.idMap) ?? '??';
             if (lname !== rname) {
-                // eslint-disable-next-line @typescript-eslint/no-base-to-string,@typescript-eslint/restrict-template-expressions
-                ctx.report.addComment(`Vertex ${id} differs in names. ${ctx.leftname}: ${lname} vs ${ctx.rightname}: ${rname}`, {
+                ctx.report.addComment(`Vertex ${id} differs in names. ${ctx.leftname}: ${String(lname)} vs ${ctx.rightname}: ${String(rname)}`, {
                     tag: 'vertex',
                     id
                 });
             }
         }
         (0, info_1.diffControlDependencies)(lInfo.controlDependencies, rInfo.controlDependencies, { ...ctx, position: `Vertex ${id} differs in controlDependencies. ` });
-        (0, diff_2.diffEnvironmentInformation)(lInfo.environment, rInfo.environment, { ...ctx, position: `${ctx.position}Vertex ${id} differs in environment. ` });
+        if ((lInfo.environment === undefined && rInfo.environment !== undefined && !ctx.config.leftIsSubgraph)
+            || (lInfo.environment !== undefined && rInfo.environment === undefined && !ctx.config.rightIsSubgraph)) {
+            /* only diff them if specified at all */
+            (0, diff_2.diffEnvironmentInformation)(lInfo.environment, rInfo.environment, {
+                ...ctx,
+                position: `${ctx.position}Vertex ${id} differs in environment. `
+            });
+        }
         if (lInfo.tag === "function-call" /* VertexType.FunctionCall */) {
             if (rInfo.tag !== "function-call" /* VertexType.FunctionCall */) {
                 ctx.report.addComment(`Vertex ${id} differs in tags. ${ctx.leftname}: ${lInfo.tag} vs. ${ctx.rightname}: ${rInfo.tag}`);
@@ -190,10 +212,13 @@ function diffVertices(ctx) {
                 if (lInfo.onlyBuiltin !== rInfo.onlyBuiltin) {
                     ctx.report.addComment(`Vertex ${id} differs in onlyBuiltin. ${ctx.leftname}: ${lInfo.onlyBuiltin} vs ${ctx.rightname}: ${rInfo.onlyBuiltin}`, { tag: 'vertex', id });
                 }
-                diffFunctionArguments(lInfo.id, lInfo.args, rInfo.args, {
-                    ...ctx,
-                    position: `${ctx.position}Vertex ${id} (function call) differs in arguments. `
-                });
+                if ((lInfo.args.length === 0 && rInfo.args.length !== 0 && !ctx.config.leftIsSubgraph)
+                    || (lInfo.args.length !== 0 && rInfo.args.length === 0 && !ctx.config.rightIsSubgraph)) {
+                    diffFunctionArguments(lInfo.id, lInfo.args, rInfo.args, {
+                        ...ctx,
+                        position: `${ctx.position}Vertex ${id} (function call) differs in arguments. `
+                    });
+                }
             }
         }
         if (lInfo.tag === 'function-definition') {
@@ -204,10 +229,13 @@ function diffVertices(ctx) {
                 if (!(0, arrays_1.arrayEqual)(lInfo.exitPoints, rInfo.exitPoints)) {
                     ctx.report.addComment(`Vertex ${id} differs in exit points. ${ctx.leftname}: ${JSON.stringify(lInfo.exitPoints, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(rInfo.exitPoints, json_1.jsonReplacer)}`, { tag: 'vertex', id });
                 }
-                (0, diff_2.diffEnvironmentInformation)(lInfo.subflow.environment, rInfo.subflow.environment, {
-                    ...ctx,
-                    position: `${ctx.position}Vertex ${id} (function definition) differs in subflow environments. `
-                });
+                if ((lInfo.subflow.environment === undefined && rInfo.subflow.environment !== undefined && !ctx.config.leftIsSubgraph)
+                    || (lInfo.subflow.environment !== undefined && rInfo.subflow.environment === undefined && !ctx.config.rightIsSubgraph)) {
+                    (0, diff_2.diffEnvironmentInformation)(lInfo.subflow.environment, rInfo.subflow.environment, {
+                        ...ctx,
+                        position: `${ctx.position}Vertex ${id} (function definition) differs in subflow environments. `
+                    });
+                }
                 (0, diff_1.setDifference)(lInfo.subflow.graph, rInfo.subflow.graph, {
                     ...ctx,
                     position: `${ctx.position}Vertex ${id} differs in subflow graph. `
@@ -229,19 +257,23 @@ function diffEdge(edge, otherEdge, ctx, id, target) {
 }
 function diffEdges(ctx, id, lEdges, rEdges) {
     if (lEdges === undefined || rEdges === undefined) {
-        if (lEdges !== rEdges) {
+        if ((lEdges === undefined && !ctx.config.leftIsSubgraph)
+            || (rEdges === undefined && !ctx.config.rightIsSubgraph)) {
             ctx.report.addComment(`Vertex ${id} has undefined outgoing edges. ${ctx.leftname}: ${JSON.stringify(lEdges, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(rEdges, json_1.jsonReplacer)}`, { tag: 'vertex', id });
         }
         return;
     }
-    if (lEdges.size !== rEdges.size) {
+    if (lEdges.size < rEdges.size && !ctx.config.leftIsSubgraph
+        || lEdges.size > rEdges.size && !ctx.config.rightIsSubgraph) {
         ctx.report.addComment(`Vertex ${id} differs in number of outgoing edges. ${ctx.leftname}: [${[...lEdges.keys()].join(',')}] vs ${ctx.rightname}: [${[...rEdges.keys()].join(',')}] `, { tag: 'vertex', id });
     }
     // order independent compare
     for (const [target, edge] of lEdges) {
         const otherEdge = rEdges.get(target);
         if (otherEdge === undefined) {
-            ctx.report.addComment(`Target of ${id}->${target} in ${ctx.leftname} is not present in ${ctx.rightname}`, { tag: 'edge', from: id, to: target });
+            if (!ctx.config.rightIsSubgraph) {
+                ctx.report.addComment(`Target of ${id}->${target} in ${ctx.leftname} is not present in ${ctx.rightname}`, { tag: 'edge', from: id, to: target });
+            }
             continue;
         }
         diffEdge(edge, otherEdge, ctx, id, target);

package/dataflow/internal/linker.d.ts

@@ -4,14 +4,19 @@ import type { IdentifierReference } from '../environments/identifier';
 import type { DataflowGraph, FunctionArgument } from '../graph/graph';
 import type { RParameter } from '../../r-bridge/lang-4.x/ast/model/nodes/r-parameter';
 import type { AstIdMap, ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { DataflowGraphVertexInfo } from '../graph/vertex';
+import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexFunctionDefinition, DataflowGraphVertexInfo } from '../graph/vertex';
 import type { REnvironmentInformation } from '../environments/environment';
 export type NameIdMap = DefaultMap<string, IdentifierReference[]>;
 export declare function produceNameSharedIdMap(references: IdentifierReference[]): NameIdMap;
 export declare function linkArgumentsOnCall(args: FunctionArgument[], params: RParameter<ParentInformation>[], graph: DataflowGraph): void;
+export declare function linkFunctionCallWithSingleTarget(graph: DataflowGraph, def: DataflowGraphVertexFunctionDefinition, info: DataflowGraphVertexFunctionCall, idMap: AstIdMap): void;
 /**
  * Returns the called functions within the current graph, which can be used to merge the environments with the call.
  * Furthermore, it links the corresponding arguments.
+ *
+ * @param graph     - The graph to use for search and resolution traversals (ideally a superset of the `thisGraph`)
+ * @param idMap     - The map to resolve ids to names
+ * @param thisGraph - The graph to search for function calls in
  */
 export declare function linkFunctionCalls(graph: DataflowGraph, idMap: AstIdMap, thisGraph: DataflowGraph): {
     functionCall: NodeId;

package/dataflow/internal/linker.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.linkCircularRedefinitionsWithinALoop = exports.linkInputs = exports.getAllLinkedFunctionDefinitions = exports.linkFunctionCalls = exports.linkArgumentsOnCall = exports.produceNameSharedIdMap = void 0;
+exports.linkCircularRedefinitionsWithinALoop = exports.linkInputs = exports.getAllLinkedFunctionDefinitions = exports.linkFunctionCalls = exports.linkFunctionCallWithSingleTarget = exports.linkArgumentsOnCall = exports.produceNameSharedIdMap = void 0;
 const defaultmap_1 = require("../../util/defaultmap");
 const assert_1 = require("../../util/assert");
 const log_1 = require("../../util/log");
@@ -79,6 +79,30 @@ function linkFunctionCallArguments(targetId, idMap, functionCallName, functionRo
     (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `linking arguments for ${functionCallName} (${functionRootId}) to ${JSON.stringify(linkedFunction.location)}`);
     linkArgumentsOnCall(callArgs, linkedFunction.parameters, finalGraph);
 }
+function linkFunctionCallWithSingleTarget(graph, def, info, idMap) {
+    const id = info.id;
+    if (info.environment !== undefined) {
+        // for each open ingoing reference, try to resolve it here, and if so, add a read edge from the call to signal that it reads it
+        for (const ingoing of def.subflow.in) {
+            const defs = ingoing.name ? (0, resolve_by_name_1.resolveByName)(ingoing.name, info.environment) : undefined;
+            if (defs === undefined) {
+                continue;
+            }
+            for (const def of defs) {
+                graph.addEdge(id, def, { type: 1 /* EdgeType.Reads */ });
+            }
+        }
+    }
+    const exitPoints = def.exitPoints;
+    for (const exitPoint of exitPoints) {
+        graph.addEdge(id, exitPoint, { type: 8 /* EdgeType.Returns */ });
+    }
+    const defName = (0, node_id_1.recoverName)(def.id, idMap);
+    (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `recording expression-list-level call from ${(0, node_id_1.recoverName)(info.id, idMap)} to ${defName}`);
+    graph.addEdge(id, def.id, { type: 4 /* EdgeType.Calls */ });
+    linkFunctionCallArguments(def.id, idMap, defName, id, info.args, graph);
+}
+exports.linkFunctionCallWithSingleTarget = linkFunctionCallWithSingleTarget;
 function linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefinitions) {
     const edges = graph.outgoingEdges(id);
     if (edges === undefined) {
@@ -91,26 +115,7 @@ function linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefin
     const functionDefs = getAllLinkedFunctionDefinitions(new Set(functionDefinitionReadIds), graph);
     for (const def of functionDefs.values()) {
         (0, assert_1.guard)(def.tag === "function-definition" /* VertexType.FunctionDefinition */, () => `expected function definition, but got ${def.tag}`);
-        if (info.environment !== undefined) {
-            // for each open ingoing reference, try to resolve it here, and if so, add a read edge from the call to signal that it reads it
-            for (const ingoing of def.subflow.in) {
-                const defs = ingoing.name ? (0, resolve_by_name_1.resolveByName)(ingoing.name, info.environment) : undefined;
-                if (defs === undefined) {
-                    continue;
-                }
-                for (const def of defs) {
-                    graph.addEdge(id, def, { type: 1 /* EdgeType.Reads */ });
-                }
-            }
-        }
-        const exitPoints = def.exitPoints;
-        for (const exitPoint of exitPoints) {
-            graph.addEdge(id, exitPoint, { type: 8 /* EdgeType.Returns */ });
-        }
-        const defName = (0, node_id_1.recoverName)(def.id, idMap);
-        (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `recording expression-list-level call from ${(0, node_id_1.recoverName)(info.id, idMap)} to ${defName}`);
-        graph.addEdge(id, def.id, { type: 4 /* EdgeType.Calls */ });
-        linkFunctionCallArguments(def.id, idMap, defName, id, info.args, graph);
+        linkFunctionCallWithSingleTarget(graph, def, info, idMap);
     }
     if (thisGraph.isRoot(id)) {
         calledFunctionDefinitions.push({ functionCall: id, called: [...functionDefs.values()] });
@@ -119,6 +124,10 @@ function linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefin
 /**
  * Returns the called functions within the current graph, which can be used to merge the environments with the call.
  * Furthermore, it links the corresponding arguments.
+ *
+ * @param graph     - The graph to use for search and resolution traversals (ideally a superset of the `thisGraph`)
+ * @param idMap     - The map to resolve ids to names
+ * @param thisGraph - The graph to search for function calls in
  */
 function linkFunctionCalls(graph, idMap, thisGraph) {
     const functionCalls = [...thisGraph.vertices(true)]

package/dataflow/internal/process/functions/process-argument.js

@@ -4,6 +4,8 @@ exports.processFunctionArgument = exports.linkReadsForArgument = void 0;
 const processor_1 = require("../../../processor");
 const collect_1 = require("../../../../r-bridge/lang-4.x/ast/model/collect");
 const graph_1 = require("../../../graph/graph");
+const edge_1 = require("../../../graph/edge");
+const resolve_by_name_1 = require("../../../environments/resolve-by-name");
 function linkReadsForArgument(root, ingoingRefs, graph) {
     const allIdsBeforeArguments = new Set((0, collect_1.collectAllIds)(root, n => n.type === "RArgument" /* RType.Argument */ && n.info.id !== root.info.id));
     const ingoingBeforeArgs = ingoingRefs.filter(r => allIdsBeforeArguments.has(r.nodeId));
@@ -13,6 +15,18 @@ function linkReadsForArgument(root, ingoingRefs, graph) {
     }
 }
 exports.linkReadsForArgument = linkReadsForArgument;
+function hasNoOutgoingCallEdge(graph, id) {
+    const outgoings = graph.outgoingEdges(id);
+    if (outgoings === undefined) {
+        return true;
+    }
+    for (const [_, edge] of outgoings) {
+        if ((0, edge_1.edgeIncludesType)(edge.types, 4 /* EdgeType.Calls */)) {
+            return false;
+        }
+    }
+    return true;
+}
 function processFunctionArgument(argument, data) {
     const name = argument.name === undefined ? undefined : (0, processor_1.processDataflowFor)(argument.name, data);
     const value = argument.value === undefined ? undefined : (0, processor_1.processDataflowFor)(argument.value, data);
@@ -29,6 +43,20 @@ function processFunctionArgument(argument, data) {
         entryPoint = argument.info.id;
     }
     const ingoingRefs = [...value?.unknownReferences ?? [], ...value?.in ?? [], ...(name === undefined ? [] : [...name.in])];
+    /* potentially link all function calls here (as maybes with a maybe cd) as the called function may employ calling-env-semantics if unknown */
+    if (value) {
+        const functionCalls = [...graph.vertices(true)]
+            .filter(([_, info]) => info.tag === "function-call" /* VertexType.FunctionCall */)
+            .filter(([id]) => hasNoOutgoingCallEdge(graph, id));
+        // try to resolve them against the current environment
+        for (const [id, info] of functionCalls) {
+            const resolved = (0, resolve_by_name_1.resolveByName)(info.name, data.environment) ?? [];
+            /* first, only link a read ref */
+            for (const resolve of resolved) {
+                graph.addEdge(id, resolve.nodeId, { type: 1 /* EdgeType.Reads */ });
+            }
+        }
+    }
     if (entryPoint && argument.value?.type === "RFunctionDefinition" /* RType.FunctionDefinition */) {
         graph.addEdge(entryPoint, argument.value.info.id, { type: 1 /* EdgeType.Reads */ });
     }

package/package.json

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

package/r-bridge/lang-4.x/ast/parser/json/format.js

@@ -23,11 +23,11 @@ function prepareParsedData(data) {
     // iterate a second time to set parent-child relations (since they may be out of order in the csv)
     for (const entry of ret.values()) {
         if (entry.parent != exports.RootId) {
-            const parent = ret.get(entry.parent);
-            if (parent) {
-                parent.children ??= [];
-                parent.children.push(entry);
-            }
+            /** it turns out that comments may return a negative id pair to their parent */
+            const parent = ret.get(Math.abs(entry.parent));
+            (0, assert_1.guard)(parent !== undefined, () => `Could not find parent ${entry.parent} for entry ${entry.id}`);
+            parent.children ??= [];
+            parent.children.push(entry);
         }
         else {
             roots.push(entry);

package/reconstruct/auto-select/auto-select-defaults.d.ts

@@ -0,0 +1,21 @@
+import type { NoInfo, RNode } from '../../r-bridge/lang-4.x/ast/model/model';
+import type { ParentInformation, NormalizedAst } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
+/**
+ * The structure of the predicate that should be used to determine
+ * if a given normalized node should be included in the reconstructed code,
+ * independent of if it is selected by the slice or not.
+ *
+ * @see reconstructToCode
+ * @see doNotAutoSelect
+ * @see autoSelectLibrary
+ */
+export type AutoSelectPredicate = (node: RNode<ParentInformation>, fullAst: NormalizedAst) => boolean;
+/**
+ * A variant of the {@link AutoSelectPredicate} which does not select any additional statements (~&gt; false)
+ */
+export declare function doNotAutoSelect(_node: RNode): boolean;
+/**
+ * A variant of the {@link AutoSelectPredicate} which does its best
+ * to select any kind of library import automatically.
+ */
+export declare function autoSelectLibrary<Info = NoInfo>(node: RNode<Info>): boolean;

package/reconstruct/auto-select/auto-select-defaults.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoSelectLibrary = exports.doNotAutoSelect = void 0;
+/**
+ * A variant of the {@link AutoSelectPredicate} which does not select any additional statements (~> false)
+ */
+function doNotAutoSelect(_node) {
+    return false;
+}
+exports.doNotAutoSelect = doNotAutoSelect;
+const libraryFunctionCall = /^(library|require|((require|load|attach)Namespace))$/;
+/**
+ * A variant of the {@link AutoSelectPredicate} which does its best
+ * to select any kind of library import automatically.
+ */
+function autoSelectLibrary(node) {
+    if (node.type !== "RFunctionCall" /* RType.FunctionCall */ || !node.named) {
+        return false;
+    }
+    return libraryFunctionCall.test(node.functionName.content);
+}
+exports.autoSelectLibrary = autoSelectLibrary;
+//# sourceMappingURL=auto-select-defaults.js.map

package/reconstruct/auto-select/magic-comments.d.ts

@@ -0,0 +1,17 @@
+import type { AutoSelectPredicate } from './auto-select-defaults';
+/**
+ * This takes an {@link NormalizedAst} and returns an auto-select predicate for {@link reconstructToCode},
+ * which will automatically include lines marked by these special comments!
+ * Please make sure to create one per source as it will use it to cache.
+ *
+ * We support two formats:
+ * - Line comments in the form of `# flowr@include_next_line` or `# flowr@include_this_line`.
+ * - Block comments which start with `# flowr@include_start` and end with `# flowr@include_end`.
+ *   This supports nesting, but they have to appear on a single line.
+ *
+ * Please note that these comments have to start exactly with this content to work.
+ *
+ * @param and - Predicate to composite this one with, If you do not pass a predicate, you may assume composition with
+ *              {@link doNotAutoSelect}.
+ */
+export declare function makeMagicCommentHandler(and?: AutoSelectPredicate): AutoSelectPredicate;

package/reconstruct/auto-select/magic-comments.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMagicCommentHandler = void 0;
+const visitor_1 = require("../../r-bridge/lang-4.x/ast/model/processing/visitor");
+const assert_1 = require("../../util/assert");
+function getLoc({ location, info: { fullRange } }) {
+    const loc = location ?? fullRange;
+    (0, assert_1.guard)(loc !== undefined, 'TODO: support location-less nodes!');
+    return loc;
+}
+const magicCommentIdMapper = {
+    'include_next_line': (n) => {
+        return [getLoc(n)[0] + 1];
+    },
+    'include_this_line': (n) => {
+        return [getLoc(n)[0]];
+    },
+    'include_start': (n, stack) => {
+        stack.push(getLoc(n)[0] + 1);
+        return undefined;
+    },
+    'include_end': (n, stack) => {
+        const to = getLoc(n)[0];
+        (0, assert_1.guard)(stack.length >= 1, `mismatched magic start and end at ${to}`);
+        const from = stack.pop();
+        const ret = new Array(to - from - 1);
+        for (let i = from; i < to; i++) {
+            ret[i - from] = i;
+        }
+        return ret;
+    }
+};
+const commentTriggerRegex = / flowr@(\w+)/;
+/**
+ * This takes an {@link NormalizedAst} and returns an auto-select predicate for {@link reconstructToCode},
+ * which will automatically include lines marked by these special comments!
+ * Please make sure to create one per source as it will use it to cache.
+ *
+ * We support two formats:
+ * - Line comments in the form of `# flowr@include_next_line` or `# flowr@include_this_line`.
+ * - Block comments which start with `# flowr@include_start` and end with `# flowr@include_end`.
+ *   This supports nesting, but they have to appear on a single line.
+ *
+ * Please note that these comments have to start exactly with this content to work.
+ *
+ * @param and - Predicate to composite this one with, If you do not pass a predicate, you may assume composition with
+ *              {@link doNotAutoSelect}.
+ */
+function makeMagicCommentHandler(and) {
+    let lines = undefined;
+    return (node, normalizedAst) => {
+        if (!lines) {
+            lines = new Set();
+            const startLineStack = [];
+            (0, visitor_1.visitAst)(normalizedAst.ast, n => {
+                const comments = n.info.additionalTokens;
+                if (!comments) {
+                    return;
+                }
+                for (const c of comments) {
+                    if (c.type !== "RComment" /* RType.Comment */ || !c.content.startsWith(' flowr@')) {
+                        continue;
+                    }
+                    const match = commentTriggerRegex.exec(c.content);
+                    (0, assert_1.guard)(match !== null, `invalid magic comment: ${c.content}`);
+                    const idMapper = magicCommentIdMapper[match[1]];
+                    (0, assert_1.guard)(idMapper !== undefined, `unknown magic comment: ${match[1]}`);
+                    const ls = idMapper(c, startLineStack);
+                    if (ls !== undefined) {
+                        for (const l of ls) {
+                            lines.add(l);
+                        }
+                    }
+                }
+            });
+            (0, assert_1.guard)(startLineStack.length === 0, `mismatched magic start and end at end of file (${JSON.stringify(startLineStack)})`);
+        }
+        const loc = node.location ?? node.info.fullRange;
+        if (loc && lines.has(loc[0])) {
+            return true;
+        }
+        return and?.(node, normalizedAst) ?? false;
+    };
+}
+exports.makeMagicCommentHandler = makeMagicCommentHandler;
+//# sourceMappingURL=magic-comments.js.map

package/reconstruct/reconstruct.d.ts

@@ -3,15 +3,11 @@
  * as the file itself is way too long). See {@link reconstructToCode}.
  * @module
  */
-import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { RNode } from '../r-bridge/lang-4.x/ast/model/model';
+import type { NormalizedAst } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { AutoSelectPredicate } from './auto-select/auto-select-defaults';
 type Selection = ReadonlySet<NodeId>;
 export declare const reconstructLogger: import("tslog").Logger<import("tslog").ILogObj>;
-/** The structure of the predicate that should be used to determine if a given normalized node should be included in the reconstructed code independent of if it is selected by the slice or not */
-export type AutoSelectPredicate = (node: RNode<ParentInformation>) => boolean;
-export declare function doNotAutoSelect(_node: RNode<ParentInformation>): boolean;
-export declare function autoSelectLibrary(node: RNode<ParentInformation>): boolean;
 export interface ReconstructionResult {
     code: string;
     /** number of lines that contain nodes that triggered the `autoSelectIf` predicate {@link reconstructToCode} */
@@ -26,5 +22,5 @@ export interface ReconstructionResult {
  *
  * @returns The number of lines for which `autoSelectIf` triggered, as well as the reconstructed code itself.
  */
-export declare function reconstructToCode<Info>(ast: NormalizedAst<Info>, selection: Selection, autoSelectIf?: AutoSelectPredicate): ReconstructionResult;
+export declare function reconstructToCode(ast: NormalizedAst, selection: Selection, autoSelectIf?: AutoSelectPredicate): ReconstructionResult;
 export {};

package/reconstruct/reconstruct.js

@@ -5,21 +5,26 @@
  * @module
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.reconstructToCode = exports.autoSelectLibrary = exports.doNotAutoSelect = exports.reconstructLogger = void 0;
+exports.reconstructToCode = exports.reconstructLogger = void 0;
 const log_1 = require("../util/log");
 const assert_1 = require("../util/assert");
 const r_function_call_1 = require("../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const stateful_fold_1 = require("../r-bridge/lang-4.x/ast/model/processing/stateful-fold");
+const auto_select_defaults_1 = require("./auto-select/auto-select-defaults");
 function plain(text) {
     return [{ line: text, indent: 0 }];
 }
 exports.reconstructLogger = log_1.log.getSubLogger({ name: 'reconstruct' });
-const getLexeme = (n) => n.info.fullLexeme ?? n.lexeme ?? '';
-const reconstructAsLeaf = (leaf, configuration) => {
-    const selectionHasLeaf = configuration.selection.has(leaf.info.id) || configuration.autoSelectIf(leaf);
+function getLexeme(n) {
+    return n.info.fullLexeme ?? n.lexeme ?? '';
+}
+function reconstructAsLeaf(leaf, configuration) {
+    const selectionHasLeaf = configuration.selection.has(leaf.info.id) || configuration.autoSelectIf(leaf, configuration.fullAst);
     return selectionHasLeaf ? foldToConst(leaf) : [];
-};
-const foldToConst = (n) => plain(getLexeme(n));
+}
+function foldToConst(n) {
+    return plain(getLexeme(n));
+}
 function indentBy(lines, indent) {
     return lines.map(({ line, indent: i }) => ({ line, indent: i + indent }));
 }
@@ -57,7 +62,7 @@ function reconstructExpressionList(exprList, _grouping, expressions, config) {
     }
 }
 function isSelected(configuration, n) {
-    return configuration.selection.has(n.info.id) || configuration.autoSelectIf(n);
+    return configuration.selection.has(n.info.id) || configuration.autoSelectIf(n, configuration.fullAst);
 }
 function reconstructRawBinaryOperator(lhs, n, rhs) {
     return [
@@ -360,18 +365,6 @@ function reconstructFunctionCall(call, functionName, args, configuration) {
         return plain(getLexeme(call));
     }
 }
-function doNotAutoSelect(_node) {
-    return false;
-}
-exports.doNotAutoSelect = doNotAutoSelect;
-const libraryFunctionCall = /^(library|require|((require|load|attach)Namespace))$/;
-function autoSelectLibrary(node) {
-    if (node.type !== "RFunctionCall" /* RType.FunctionCall */ || !node.named) {
-        return false;
-    }
-    return libraryFunctionCall.test(node.functionName.content);
-}
-exports.autoSelectLibrary = autoSelectLibrary;
 /**
  * The fold functions used to reconstruct the ast in {@link reconstructToCode}.
  */
@@ -431,14 +424,14 @@ function removeOuterExpressionListIfApplicable(result, linesWithAutoSelected) {
  *
  * @returns The number of lines for which `autoSelectIf` triggered, as well as the reconstructed code itself.
  */
-function reconstructToCode(ast, selection, autoSelectIf = autoSelectLibrary) {
+function reconstructToCode(ast, selection, autoSelectIf = auto_select_defaults_1.autoSelectLibrary) {
     if (exports.reconstructLogger.settings.minLevel <= 1 /* LogLevel.Trace */) {
         exports.reconstructLogger.trace(`reconstruct ast with ids: ${JSON.stringify([...selection])}`);
     }
     // we use a wrapper to count the number of lines for which the autoSelectIf predicate triggered
     const linesWithAutoSelected = new Set();
     const autoSelectIfWrapper = (node) => {
-        const result = autoSelectIf(node);
+        const result = autoSelectIf(node, ast);
         if (result && node.location) {
             for (let i = node.location[0]; i <= node.location[2]; i++) {
                 linesWithAutoSelected.add(i);
@@ -447,7 +440,7 @@ function reconstructToCode(ast, selection, autoSelectIf = autoSelectLibrary) {
         return result;
     };
     // fold of the normalized ast
-    const result = (0, stateful_fold_1.foldAstStateful)(ast.ast, { selection, autoSelectIf: autoSelectIfWrapper }, reconstructAstFolds);
+    const result = (0, stateful_fold_1.foldAstStateful)(ast.ast, { selection, autoSelectIf: autoSelectIfWrapper, fullAst: ast }, reconstructAstFolds);
     (0, log_1.expensiveTrace)(exports.reconstructLogger, () => `reconstructed ast before string conversion: ${JSON.stringify(result)}`);
     return removeOuterExpressionListIfApplicable(result, linesWithAutoSelected.size);
 }

package/slicing/static/static-slicer.d.ts

@@ -4,8 +4,13 @@ import type { NormalizedAst } from '../../r-bridge/lang-4.x/ast/model/processing
 import type { SlicingCriteria } from '../criterion/parse';
 export declare const slicerLogger: import("tslog").Logger<import("tslog").ILogObj>;
 /**
- * This returns the ids to include in the slice, when slicing with the given seed id's (must be at least one).
+ * This returns the ids to include in the static backward slice, when slicing with the given seed id's (must be at least one).
  * <p>
  * The returned ids can be used to {@link reconstructToCode|reconstruct the slice to R code}.
+ *
+ * @param graph     - The dataflow graph to conduct the slicing on.
+ * @param ast       - The normalized AST of the code (used to get static depth information of the lexemes in case of control flow dependencies that may have no effect on the slicing scope).
+ * @param criteria  - The criteras to slice on.
+ * @param threshold - The maximum number of nodes to visit in the graph. If the threshold is reached, the slice will side with inclusion and drop its minimal guarantee. The limit ensures that the algorithm halts.
  */
 export declare function staticSlicing(graph: DataflowGraph, ast: NormalizedAst, criteria: SlicingCriteria, threshold?: number): Readonly<SliceResult>;

package/slicing/static/static-slicer.js

@@ -11,9 +11,14 @@ const environment_1 = require("../../dataflow/environments/environment");
 const edge_1 = require("../../dataflow/graph/edge");
 exports.slicerLogger = log_1.log.getSubLogger({ name: 'slicer' });
 /**
- * This returns the ids to include in the slice, when slicing with the given seed id's (must be at least one).
+ * This returns the ids to include in the static backward slice, when slicing with the given seed id's (must be at least one).
  * <p>
  * The returned ids can be used to {@link reconstructToCode|reconstruct the slice to R code}.
+ *
+ * @param graph     - The dataflow graph to conduct the slicing on.
+ * @param ast       - The normalized AST of the code (used to get static depth information of the lexemes in case of control flow dependencies that may have no effect on the slicing scope).
+ * @param criteria  - The criteras to slice on.
+ * @param threshold - The maximum number of nodes to visit in the graph. If the threshold is reached, the slice will side with inclusion and drop its minimal guarantee. The limit ensures that the algorithm halts.
  */
 function staticSlicing(graph, ast, criteria, threshold = 75) {
     (0, assert_1.guard)(criteria.length > 0, 'must have at least one seed id to calculate slice');
@@ -26,11 +31,11 @@ function staticSlicing(graph, ast, criteria, threshold = 75) {
     {
         const emptyEnv = (0, environment_1.initializeCleanEnvironments)();
         const basePrint = (0, fingerprint_1.envFingerprint)(emptyEnv);
-        for (const startId of decodedCriteria) {
-            queue.add(startId.id, emptyEnv, basePrint, false);
+        for (const { id: startId } of decodedCriteria) {
+            queue.add(startId, emptyEnv, basePrint, false);
             // retrieve the minimum depth of all nodes to only add control dependencies if they are "part" of the current execution
-            minDepth = Math.min(minDepth, ast.idMap.get(startId.id)?.info.depth ?? minDepth);
-            sliceSeedIds.add(startId.id);
+            minDepth = Math.min(minDepth, ast.idMap.get(startId)?.info.depth ?? minDepth);
+            sliceSeedIds.add(startId);
         }
     }
     while (queue.nonEmpty()) {

package/util/diff.d.ts

@@ -39,5 +39,17 @@ export interface GenericDifferenceInformation<Report extends WriteableDifference
     readonly report: Report;
     /** A human-readable indication of where we are (the prefix of the information if the structures differ) */
     readonly position: string;
+    readonly config: GenericDiffConfiguration;
+}
+export interface GenericDiffConfiguration {
+    /**
+     * The left graph may contain more vertices and or edges than the right graph.
+     * However, those which are the same (based on their ids) have to be equal
+     */
+    readonly rightIsSubgraph?: boolean;
+    /**
+     * Similar to {@link rightIsSubgraph}, but for the left graph.
+     */
+    readonly leftIsSubgraph?: boolean;
 }
 export declare function setDifference<T, Report extends WriteableDifferenceReport = WriteableDifferenceReport>(left: ReadonlySet<T>, right: ReadonlySet<T>, info: GenericDifferenceInformation<Report>): void;

package/util/diff.js

@@ -15,14 +15,17 @@ function setDifference(left, right, info) {
         return;
     }
     let message = info.position;
-    if (lWithoutR.size > 0) {
+    if (lWithoutR.size > 0 && !info.config.rightIsSubgraph) {
         message += ` More elements in ${info.leftname}: ${JSON.stringify([...lWithoutR])}`;
     }
-    if (rWithoutL.size > 0) {
+    if (rWithoutL.size > 0 && !info.config.leftIsSubgraph) {
         message += lWithoutR.size > 0 ? ' and m' : 'M';
         message += `ore in ${info.rightname}: ${JSON.stringify([...rWithoutL])}`;
     }
-    info.report.addComment(message);
+    if ((rWithoutL.size > 0 && !info.config.leftIsSubgraph)
+        || (lWithoutR.size > 0 && !info.config.rightIsSubgraph)) {
+        info.report.addComment(message);
+    }
 }
 exports.setDifference = setDifference;
 //# sourceMappingURL=diff.js.map

package/util/mermaid/dfg.d.ts

@@ -13,6 +13,9 @@ interface MermaidGraph {
     presentEdges: Set<string>;
     rootGraph: DataflowGraph;
 }
+/**
+ * Prints a {@link SourceRange|range} as a human readable string.
+ */
 export declare function formatRange(range: SourceRange | undefined): string;
 interface MermaidGraphConfiguration {
     graph: DataflowGraph;

package/util/mermaid/dfg.js

@@ -7,6 +7,9 @@ const graph_1 = require("../../dataflow/graph/graph");
 const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const edge_1 = require("../../dataflow/graph/edge");
 const environment_1 = require("../../dataflow/environments/environment");
+/**
+ * Prints a {@link SourceRange|range} as a human readable string.
+ */
 function formatRange(range) {
     if (range === undefined) {
         return '??-??';

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.14';
+const version = '2.0.15';
 function flowrVersion() {
     return new semver_1.SemVer(version);
 }