@eagleoutice/flowr 1.3.14 → 1.4.1

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

@@ -1,6 +1,6 @@
-import { DataflowGraph } from '../../dataflow';
-import { NodeId, NormalizedAst } from '../../r-bridge';
-import { DecodedCriteria, SlicingCriteria } from '../criterion';
+import type { DataflowGraph } from '../../dataflow';
+import type { NodeId, NormalizedAst } from '../../r-bridge';
+import type { DecodedCriteria, SlicingCriteria } from '../criterion';
 export declare const slicerLogger: import("tslog").Logger<import("tslog").ILogObj>;
 /**
  * The result of the slice step

package/statistics/features/common-syntax-probability.d.ts

@@ -1,8 +1,9 @@
 /**
  * Defines the type of syntax constructs that we track (e.g., true, false, 0, 1, T, F, conditions...)
  */
-import { RFalse, RNodeWithParent, RTrue } from '../../r-bridge';
-import { SummarizedMeasurement } from '../../util/summarizer/benchmark/data';
+import type { RNodeWithParent } from '../../r-bridge';
+import { RFalse, RTrue } from '../../r-bridge';
+import type { SummarizedMeasurement } from '../../util/summarizer/benchmark/data';
 export interface CommonSyntaxTypeCounts<Measurement = bigint> {
     total: Measurement;
     multiple: Measurement;

package/statistics/features/common-syntax-probability.js

@@ -1,9 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.summarizeCommonSyntaxTypeCounter = exports.appendCommonSyntaxTypeCounter = exports.updateCommonSyntaxTypeCounts = exports.emptyCommonSyntaxTypeCounts = void 0;
-/**
- * Defines the type of syntax constructs that we track (e.g., true, false, 0, 1, T, F, conditions...)
- */
 const r_bridge_1 = require("../../r-bridge");
 const process_1 = require("../../util/summarizer/benchmark/first-phase/process");
 const numbers_1 = require("../../util/numbers");

package/statistics/features/feature.d.ts

@@ -1,9 +1,9 @@
-import { EvalOptions } from 'xpath-ts2/src/parse-api';
-import { MergeableRecord } from '../../util/objects';
-import { NormalizedAst } from '../../r-bridge';
-import { DataflowInformation } from '../../dataflow/internal/info';
-import { MetaStatistics } from '../meta-statistics';
-import { StatisticsSummarizerConfiguration } from '../../util/summarizer/statistics/summarizer';
+import type { EvalOptions } from 'xpath-ts2/src/parse-api';
+import type { MergeableRecord } from '../../util/objects';
+import type { NormalizedAst } from '../../r-bridge';
+import type { DataflowInformation } from '../../dataflow/internal/info';
+import type { MetaStatistics } from '../meta-statistics';
+import type { StatisticsSummarizerConfiguration } from '../../util/summarizer/statistics/summarizer';
 /**
  * Maps each sub-feature name to the number of occurrences of that sub-feature.
  * Allows for one nesting level to denote hierarchical features.

package/statistics/features/post-processing.d.ts

@@ -1,5 +1,5 @@
-import { MergeableRecord } from '../../util/objects';
-import { StatisticsSummarizerConfiguration } from '../../util/summarizer/statistics/summarizer';
+import type { MergeableRecord } from '../../util/objects';
+import type { StatisticsSummarizerConfiguration } from '../../util/summarizer/statistics/summarizer';
 export interface SummarizedWithProject<Uniques = Set<string>, Count = number[]> {
     uniqueProjects: Uniques;
     uniqueFiles: Uniques;

package/statistics/features/supported/assignments/assignments.d.ts

@@ -1,5 +1,5 @@
-import { Feature } from '../../feature';
-import { Writable } from 'ts-essentials';
+import type { Feature } from '../../feature';
+import type { Writable } from 'ts-essentials';
 declare const initialAssignmentInfo: {
     assignmentOperator: Record<string, bigint>;
     assigned: import("../../common-syntax-probability").CommonSyntaxTypeCounts<bigint>;

package/statistics/features/supported/assignments/post-process.d.ts

@@ -1,3 +1,3 @@
-import { FeatureStatisticsWithMeta } from '../../feature';
-import { StatisticsSummarizerConfiguration } from '../../../../util/summarizer/statistics/summarizer';
+import type { FeatureStatisticsWithMeta } from '../../feature';
+import type { StatisticsSummarizerConfiguration } from '../../../../util/summarizer/statistics/summarizer';
 export declare function postProcess(featureRoot: string, info: Map<string, FeatureStatisticsWithMeta>, outputPath: string, config: StatisticsSummarizerConfiguration): void;

package/statistics/features/supported/comments/comments.d.ts

@@ -1,5 +1,5 @@
-import { Feature } from '../../feature';
-import { Writable } from 'ts-essentials';
+import type { Feature } from '../../feature';
+import type { Writable } from 'ts-essentials';
 export declare const initialCommentInfo: {
     totalAmount: number;
     roxygenComments: number;

package/statistics/features/supported/comments/post-process.d.ts

@@ -1,3 +1,3 @@
-import { FeatureStatisticsWithMeta } from '../../feature';
-import { StatisticsSummarizerConfiguration } from '../../../../util/summarizer/statistics/summarizer';
+import type { FeatureStatisticsWithMeta } from '../../feature';
+import type { StatisticsSummarizerConfiguration } from '../../../../util/summarizer/statistics/summarizer';
 export declare function postProcess(featureRoot: string, info: Map<string, FeatureStatisticsWithMeta>, outputPath: string, config: StatisticsSummarizerConfiguration): void;

package/statistics/features/supported/control-flow/control-flow.d.ts

@@ -1,5 +1,5 @@
-import { Feature } from '../../feature';
-import { Writable } from 'ts-essentials';
+import type { Feature } from '../../feature';
+import type { Writable } from 'ts-essentials';
 declare const initialControlflowInfo: {
     ifThen: import("../../common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
     thenBody: import("../../common-syntax-probability").CommonSyntaxTypeCounts<bigint>;

package/statistics/features/supported/control-flow/post-process.d.ts

@@ -1,3 +1,3 @@
-import { FeatureStatisticsWithMeta } from '../../feature';
-import { StatisticsSummarizerConfiguration } from '../../../../util/summarizer/statistics/summarizer';
+import type { FeatureStatisticsWithMeta } from '../../feature';
+import type { StatisticsSummarizerConfiguration } from '../../../../util/summarizer/statistics/summarizer';
 export declare function postProcess(featureRoot: string, info: Map<string, FeatureStatisticsWithMeta>, outputPath: string, config: StatisticsSummarizerConfiguration): void;

package/statistics/features/supported/data-access/data-access.d.ts

@@ -1,6 +1,6 @@
-import { Feature } from '../../feature';
-import { Writable } from 'ts-essentials';
-import { CommonSyntaxTypeCounts } from '../../common-syntax-probability';
+import type { Feature } from '../../feature';
+import type { Writable } from 'ts-essentials';
+import type { CommonSyntaxTypeCounts } from '../../common-syntax-probability';
 declare const initialDataAccessInfo: {
     singleBracket: Record<number, bigint | CommonSyntaxTypeCounts<bigint>>;
     doubleBracket: Record<number, bigint | CommonSyntaxTypeCounts<bigint>>;

package/statistics/features/supported/data-access/post-process.d.ts

@@ -1,3 +1,3 @@
-import { FeatureStatisticsWithMeta } from '../../feature';
-import { StatisticsSummarizerConfiguration } from '../../../../util/summarizer/statistics/summarizer';
+import type { FeatureStatisticsWithMeta } from '../../feature';
+import type { StatisticsSummarizerConfiguration } from '../../../../util/summarizer/statistics/summarizer';
 export declare function postProcess(featureRoot: string, info: Map<string, FeatureStatisticsWithMeta>, outputPath: string, config: StatisticsSummarizerConfiguration): void;

package/statistics/features/supported/defined-functions/defined-functions.d.ts

@@ -1,7 +1,7 @@
-import { Feature } from '../../feature';
-import { Writable } from 'ts-essentials';
-import { SourcePosition } from '../../../../util/range';
-import { MergeableRecord } from '../../../../util/objects';
+import type { Feature } from '../../feature';
+import type { Writable } from 'ts-essentials';
+import type { SourcePosition } from '../../../../util/range';
+import type { MergeableRecord } from '../../../../util/objects';
 declare const initialFunctionDefinitionInfo: {
     /** all, anonymous, assigned, non-assigned, ... */
     total: number;

package/statistics/features/supported/defined-functions/post-process.d.ts

@@ -1,5 +1,5 @@
-import { FeatureStatisticsWithMeta } from '../../feature';
-import { StatisticsSummarizerConfiguration } from '../../../../util/summarizer/statistics/summarizer';
+import type { FeatureStatisticsWithMeta } from '../../feature';
+import type { StatisticsSummarizerConfiguration } from '../../../../util/summarizer/statistics/summarizer';
 /**
  * Note: the summary does not contain a 0 for each function that is _not_ called by a file. Hence, the minimum can not be 0 (division for mean etc. will still be performed on total file count)
  */

package/statistics/features/supported/expression-list/expression-list.d.ts

@@ -1,5 +1,5 @@
-import { Writable } from 'ts-essentials';
-import { Feature } from '../../feature';
+import type { Writable } from 'ts-essentials';
+import type { Feature } from '../../feature';
 declare const initialExpressionListInfo: {
     allExpressionLists: number;
     deepestNesting: number;

package/statistics/features/supported/expression-list/post-process.d.ts

@@ -1,3 +1,3 @@
-import { FeatureStatisticsWithMeta } from '../../feature';
-import { StatisticsSummarizerConfiguration } from '../../../../util/summarizer/statistics/summarizer';
+import type { FeatureStatisticsWithMeta } from '../../feature';
+import type { StatisticsSummarizerConfiguration } from '../../../../util/summarizer/statistics/summarizer';
 export declare function postProcess(featureRoot: string, info: Map<string, FeatureStatisticsWithMeta>, outputPath: string, config: StatisticsSummarizerConfiguration): void;

package/statistics/features/supported/loops/loops.d.ts

@@ -1,5 +1,5 @@
-import { Feature } from '../../feature';
-import { Writable } from 'ts-essentials';
+import type { Feature } from '../../feature';
+import type { Writable } from 'ts-essentials';
 declare const initialLoopInfo: {
     forLoops: import("../../common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
     forLoopVar: import("../../common-syntax-probability").CommonSyntaxTypeCounts<bigint>;

package/statistics/features/supported/loops/post-process.d.ts

@@ -1,3 +1,3 @@
-import { FeatureStatisticsWithMeta } from '../../feature';
-import { StatisticsSummarizerConfiguration } from '../../../../util/summarizer/statistics/summarizer';
+import type { FeatureStatisticsWithMeta } from '../../feature';
+import type { StatisticsSummarizerConfiguration } from '../../../../util/summarizer/statistics/summarizer';
 export declare function postProcess(featureRoot: string, info: Map<string, FeatureStatisticsWithMeta>, outputPath: string, config: StatisticsSummarizerConfiguration): void;

package/statistics/features/supported/used-functions/post-process.d.ts

@@ -1,5 +1,5 @@
-import { FeatureStatisticsWithMeta } from '../../feature';
-import { StatisticsSummarizerConfiguration } from '../../../../util/summarizer/statistics/summarizer';
+import type { FeatureStatisticsWithMeta } from '../../feature';
+import type { StatisticsSummarizerConfiguration } from '../../../../util/summarizer/statistics/summarizer';
 /**
  * Note: the summary does not contain a 0 for each function that is _not_ called by a file. Hence, the minimum can not be 0 (division for mean etc. will still be performed on total file count)
  */

package/statistics/features/supported/used-functions/used-functions.d.ts

@@ -1,6 +1,6 @@
-import { Feature } from '../../feature';
-import { Writable } from 'ts-essentials';
-import { CommonSyntaxTypeCounts } from '../../common-syntax-probability';
+import type { Feature } from '../../feature';
+import type { Writable } from 'ts-essentials';
+import type { CommonSyntaxTypeCounts } from '../../common-syntax-probability';
 declare const initialFunctionUsageInfo: {
     allFunctionCalls: number;
     args: Record<number, bigint | CommonSyntaxTypeCounts<bigint>>;

package/statistics/features/supported/used-packages/post-process.d.ts

@@ -1,3 +1,3 @@
-import { FeatureStatisticsWithMeta } from '../../feature';
-import { StatisticsSummarizerConfiguration } from '../../../../util/summarizer/statistics/summarizer';
+import type { FeatureStatisticsWithMeta } from '../../feature';
+import type { StatisticsSummarizerConfiguration } from '../../../../util/summarizer/statistics/summarizer';
 export declare function postProcess(featureRoot: string, info: Map<string, FeatureStatisticsWithMeta>, outputPath: string, config: StatisticsSummarizerConfiguration): void;

package/statistics/features/supported/used-packages/used-packages.d.ts

@@ -1,5 +1,5 @@
-import { Feature } from '../../feature';
-import { Writable } from 'ts-essentials';
+import type { Feature } from '../../feature';
+import type { Writable } from 'ts-essentials';
 export declare const initialUsedPackageInfos: {
     library: number;
     require: number;

package/statistics/features/supported/values/post-process.d.ts

@@ -1,3 +1,3 @@
-import { FeatureStatisticsWithMeta } from '../../feature';
-import { StatisticsSummarizerConfiguration } from '../../../../util/summarizer/statistics/summarizer';
+import type { FeatureStatisticsWithMeta } from '../../feature';
+import type { StatisticsSummarizerConfiguration } from '../../../../util/summarizer/statistics/summarizer';
 export declare function postProcess(featureRoot: string, info: Map<string, FeatureStatisticsWithMeta>, outputPath: string, config: StatisticsSummarizerConfiguration): void;

package/statistics/features/supported/values/values.d.ts

@@ -1,5 +1,5 @@
-import { Feature } from '../../feature';
-import { Writable } from 'ts-essentials';
+import type { Feature } from '../../feature';
+import type { Writable } from 'ts-essentials';
 declare const initialValueInfo: {
     allNumerics: number;
     imaginaryNumbers: number;

package/statistics/features/supported/variables/post-process.d.ts

@@ -1,6 +1,6 @@
-import { FeatureStatisticsWithMeta } from '../../feature';
-import { StatisticsSummarizerConfiguration } from '../../../../util/summarizer/statistics/summarizer';
-import { SummarizedWithProject } from '../../post-processing';
+import type { FeatureStatisticsWithMeta } from '../../feature';
+import type { StatisticsSummarizerConfiguration } from '../../../../util/summarizer/statistics/summarizer';
+import type { SummarizedWithProject } from '../../post-processing';
 export declare function postProcess(featureRoot: string, info: Map<string, FeatureStatisticsWithMeta>, outputPath: string, config: StatisticsSummarizerConfiguration): void;
 type VariableInfoMap = Map<string, SummarizedWithProject & {
     linePercentageInFile: number[][];

package/statistics/features/supported/variables/variables.d.ts

@@ -1,5 +1,5 @@
-import { Feature } from '../../feature';
-import { Writable } from 'ts-essentials';
+import type { Feature } from '../../feature';
+import type { Writable } from 'ts-essentials';
 declare const initialVariableInfo: {
     numberOfVariableUses: number;
     numberOfDefinitions: number;

package/statistics/meta-statistics.d.ts

@@ -1,4 +1,4 @@
-import { RParseRequestFromFile, RParseRequestFromText } from '../r-bridge';
+import type { RParseRequestFromFile, RParseRequestFromText } from '../r-bridge';
 /**
  * Statistics on skipped files, the time required, and more.
  *

package/statistics/output/print-stats.d.ts

@@ -1,5 +1,5 @@
-import { FeatureKey, FeatureStatistics } from '../features';
-import { MetaStatistics } from '../meta-statistics';
+import type { FeatureKey, FeatureStatistics } from '../features';
+import type { MetaStatistics } from '../meta-statistics';
 interface MinMaxAvgMedian {
     sum: number;
     min: number;

package/statistics/output/statistics-file.d.ts

@@ -1,4 +1,4 @@
-import { DummyAppendMemoryMap, StatisticAppendProvider } from './file-provider';
+import type { DummyAppendMemoryMap, StatisticAppendProvider } from './file-provider';
 /**
  * Requires source information to be attached on parsing!
  * <p>

package/statistics/statistics.d.ts

@@ -1,7 +1,7 @@
-import { RParseRequestFromFile, RParseRequestFromText, RShell } from '../r-bridge';
-import { FeatureSelection, FeatureStatistics } from './features';
-import { MetaStatistics } from './meta-statistics';
-import { StepResults } from '../core';
+import type { RParseRequestFromFile, RParseRequestFromText, RShell } from '../r-bridge';
+import type { FeatureSelection, FeatureStatistics } from './features';
+import type { MetaStatistics } from './meta-statistics';
+import type { StepResults } from '../core';
 /**
  * By default, {@link extractUsageStatistics} requires a generator, but sometimes you already know all the files
  * that you want to process. This function simply reps your requests as a generator.

package/util/{cfg.d.ts → cfg/cfg.d.ts}

@@ -1,8 +1,20 @@
-import { NodeId, NormalizedAst, ParentInformation, RFalse, RTrue } from '../r-bridge';
-import { MergeableRecord } from './objects';
-import { QuadSerializationConfiguration } from './quads';
+import type { NodeId, NormalizedAst, ParentInformation } from '../../r-bridge';
+import { RFalse, RTrue } from '../../r-bridge';
+import type { MergeableRecord } from '../objects';
+import type { QuadSerializationConfiguration } from '../quads';
+export declare const enum CfgVertexType {
+    /** Marks a break point in a construct (e.g., between the name and the value of an argument, or the formals and the body of a function)  */
+    MidMarker = "mid-marker",
+    /** The explicit exit-nodes to ensure the hammock property */
+    EndMarker = "end-marker",
+    /** something like an if, assignment, ... even though in the classical sense of R they are still expressions */
+    Statement = "statement",
+    /** something like an addition, ... */
+    Expression = "expression"
+}
 export interface CfgVertex {
     id: NodeId;
+    type: CfgVertexType;
     name: string;
     /** in case of a function definition */
     children?: NodeId[];
@@ -14,7 +26,7 @@ interface CfgControlDependencyEdge extends MergeableRecord {
     label: 'CD';
     when: typeof RTrue | typeof RFalse;
 }
-export type CFGEdge = CfgFlowDependencyEdge | CfgControlDependencyEdge;
+export type CfgEdge = CfgFlowDependencyEdge | CfgControlDependencyEdge;
 /**
  * This class represents the control flow graph of an R program.
  * The control flow may be hierarchical when confronted with function definitions (see {@link CfgVertex} and {@link CFG#rootVertexIds|rootVertexIds()}).
@@ -24,10 +36,10 @@ export declare class ControlFlowGraph {
     private vertexInformation;
     private edgeInformation;
     addVertex(vertex: CfgVertex, rootVertex?: boolean): this;
-    addEdge(from: NodeId, to: NodeId, edge: CFGEdge): this;
+    addEdge(from: NodeId, to: NodeId, edge: CfgEdge): this;
     rootVertexIds(): ReadonlySet<NodeId>;
     vertices(): ReadonlyMap<NodeId, CfgVertex>;
-    edges(): ReadonlyMap<NodeId, ReadonlyMap<NodeId, CFGEdge>>;
+    edges(): ReadonlyMap<NodeId, ReadonlyMap<NodeId, CfgEdge>>;
     merge(other: ControlFlowGraph, forceNested?: boolean): this;
 }
 export interface ControlFlowInformation extends MergeableRecord {

package/util/{cfg.js → cfg/cfg.js}

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cfg2quads = exports.equalCfg = exports.extractCFG = exports.emptyControlFlowInformation = exports.ControlFlowGraph = void 0;
-const r_bridge_1 = require("../r-bridge");
-const set_1 = require("./set");
-const quads_1 = require("./quads");
-const log_1 = require("./log");
-const json_1 = require("./json");
+const r_bridge_1 = require("../../r-bridge");
+const set_1 = require("../set");
+const quads_1 = require("../quads");
+const log_1 = require("../log");
+const json_1 = require("../json");
 /**
  * This class represents the control flow graph of an R program.
  * The control flow may be hierarchical when confronted with function definitions (see {@link CfgVertex} and {@link CFG#rootVertexIds|rootVertexIds()}).
@@ -65,10 +65,10 @@ function emptyControlFlowInformation() {
 }
 exports.emptyControlFlowInformation = emptyControlFlowInformation;
 const cfgFolds = {
-    foldNumber: cfgLeaf,
-    foldString: cfgLeaf,
-    foldLogical: cfgLeaf,
-    foldSymbol: cfgLeaf,
+    foldNumber: cfgLeaf("expression" /* CfgVertexType.Expression */),
+    foldString: cfgLeaf("expression" /* CfgVertexType.Expression */),
+    foldLogical: cfgLeaf("expression" /* CfgVertexType.Expression */),
+    foldSymbol: cfgLeaf("expression" /* CfgVertexType.Expression */),
     foldAccess: cfgAccess,
     binaryOp: {
         foldLogicalOp: cfgBinaryOp,
@@ -107,24 +107,29 @@ function extractCFG(ast) {
     return (0, r_bridge_1.foldAst)(ast.ast, cfgFolds);
 }
 exports.extractCFG = extractCFG;
-function cfgLeaf(leaf) {
-    const graph = new ControlFlowGraph();
-    graph.addVertex({ id: leaf.info.id, name: leaf.type });
-    return { graph, breaks: [], nexts: [], returns: [], exitPoints: [leaf.info.id], entryPoints: [leaf.info.id] };
+function cfgLeaf(type) {
+    return (leaf) => {
+        const graph = new ControlFlowGraph();
+        graph.addVertex({ id: leaf.info.id, name: leaf.type, type });
+        return { graph, breaks: [], nexts: [], returns: [], exitPoints: [leaf.info.id], entryPoints: [leaf.info.id] };
+    };
 }
 function cfgBreak(leaf) {
-    return { ...cfgLeaf(leaf), breaks: [leaf.info.id] };
+    return { ...cfgLeaf("statement" /* CfgVertexType.Statement */)(leaf), breaks: [leaf.info.id] };
 }
 function cfgNext(leaf) {
-    return { ...cfgLeaf(leaf), nexts: [leaf.info.id] };
+    return { ...cfgLeaf("statement" /* CfgVertexType.Statement */)(leaf), nexts: [leaf.info.id] };
 }
 function cfgIgnore(_leaf) {
     return { graph: new ControlFlowGraph(), breaks: [], nexts: [], returns: [], exitPoints: [], entryPoints: [] };
 }
+function identifyMayStatementType(node) {
+    return node.info.role === "expr-list-child" /* RoleInParent.ExpressionListChild */ ? "statement" /* CfgVertexType.Statement */ : "expression" /* CfgVertexType.Expression */;
+}
 function cfgIfThenElse(ifNode, condition, then, otherwise) {
     const graph = new ControlFlowGraph();
-    graph.addVertex({ id: ifNode.info.id, name: ifNode.type });
-    graph.addVertex({ id: ifNode.info.id + '-exit', name: 'if-exit' });
+    graph.addVertex({ id: ifNode.info.id, name: ifNode.type, type: identifyMayStatementType(ifNode) });
+    graph.addVertex({ id: ifNode.info.id + '-exit', name: 'if-exit', type: "end-marker" /* CfgVertexType.EndMarker */ });
     graph.merge(condition.graph);
     graph.merge(then.graph);
     if (otherwise) {
@@ -160,8 +165,8 @@ function cfgIfThenElse(ifNode, condition, then, otherwise) {
 }
 function cfgRepeat(repeat, body) {
     const graph = body.graph;
-    graph.addVertex({ id: repeat.info.id, name: repeat.type });
-    graph.addVertex({ id: repeat.info.id + '-exit', name: 'repeat-exit' });
+    graph.addVertex({ id: repeat.info.id, name: repeat.type, type: identifyMayStatementType(repeat) });
+    graph.addVertex({ id: repeat.info.id + '-exit', name: 'repeat-exit', type: "end-marker" /* CfgVertexType.EndMarker */ });
     for (const entryPoint of body.entryPoints) {
         graph.addEdge(repeat.info.id, entryPoint, { label: 'FD' });
     }
@@ -176,8 +181,8 @@ function cfgRepeat(repeat, body) {
 }
 function cfgWhile(whileLoop, condition, body) {
     const graph = condition.graph;
-    graph.addVertex({ id: whileLoop.info.id, name: whileLoop.type });
-    graph.addVertex({ id: whileLoop.info.id + '-exit', name: 'while-exit' });
+    graph.addVertex({ id: whileLoop.info.id, name: whileLoop.type, type: identifyMayStatementType(whileLoop) });
+    graph.addVertex({ id: whileLoop.info.id + '-exit', name: 'while-exit', type: "end-marker" /* CfgVertexType.EndMarker */ });
     graph.merge(body.graph);
     for (const entry of condition.entryPoints) {
         graph.addEdge(entry, whileLoop.info.id, { label: 'FD' });
@@ -204,8 +209,8 @@ function cfgWhile(whileLoop, condition, body) {
 }
 function cfgFor(forLoop, variable, vector, body) {
     const graph = variable.graph;
-    graph.addVertex({ id: forLoop.info.id, name: forLoop.type });
-    graph.addVertex({ id: forLoop.info.id + '-exit', name: 'for-exit' });
+    graph.addVertex({ id: forLoop.info.id, name: forLoop.type, type: identifyMayStatementType(forLoop) });
+    graph.addVertex({ id: forLoop.info.id + '-exit', name: 'for-exit', type: "end-marker" /* CfgVertexType.EndMarker */ });
     graph.merge(vector.graph);
     graph.merge(body.graph);
     for (const entry of vector.entryPoints) {
@@ -236,9 +241,9 @@ function cfgFor(forLoop, variable, vector, body) {
 function cfgFunctionDefinition(fn, params, body) {
     const graph = new ControlFlowGraph();
     const children = [fn.info.id + '-params', fn.info.id + '-exit'];
-    graph.addVertex({ id: fn.info.id + '-params', name: 'function-parameters' }, false);
-    graph.addVertex({ id: fn.info.id + '-exit', name: 'function-exit' }, false);
-    graph.addVertex({ id: fn.info.id, name: fn.type, children });
+    graph.addVertex({ id: fn.info.id + '-params', name: 'function-parameters', type: "mid-marker" /* CfgVertexType.MidMarker */ }, false);
+    graph.addVertex({ id: fn.info.id + '-exit', name: 'function-exit', type: "end-marker" /* CfgVertexType.EndMarker */ }, false);
+    graph.addVertex({ id: fn.info.id, name: fn.type, children, type: identifyMayStatementType(fn) });
     graph.merge(body.graph, true);
     children.push(...body.graph.rootVertexIds());
     for (const param of params) {
@@ -263,15 +268,15 @@ function cfgFunctionDefinition(fn, params, body) {
 function cfgFunctionCall(call, name, args) {
     const graph = name.graph;
     const info = { graph, breaks: [...name.breaks], nexts: [...name.nexts], returns: [...name.returns], exitPoints: [call.info.id + '-exit'], entryPoints: [call.info.id] };
-    graph.addVertex({ id: call.info.id, name: call.type });
+    graph.addVertex({ id: call.info.id, name: call.type, type: identifyMayStatementType(call) });
     for (const entryPoint of name.entryPoints) {
         graph.addEdge(entryPoint, call.info.id, { label: 'FD' });
     }
-    graph.addVertex({ id: call.info.id + '-name', name: 'call-name' });
+    graph.addVertex({ id: call.info.id + '-name', name: 'call-name', type: "mid-marker" /* CfgVertexType.MidMarker */ });
     for (const exitPoint of name.exitPoints) {
         graph.addEdge(call.info.id + '-name', exitPoint, { label: 'FD' });
     }
-    graph.addVertex({ id: call.info.id + '-exit', name: 'call-exit' });
+    graph.addVertex({ id: call.info.id + '-exit', name: 'call-exit', type: "end-marker" /* CfgVertexType.EndMarker */ });
     let lastArgExits = [call.info.id + '-name'];
     for (const arg of args) {
         if (arg === undefined) {
@@ -297,7 +302,7 @@ function cfgFunctionCall(call, name, args) {
 function cfgArgumentOrParameter(node, name, value) {
     const graph = new ControlFlowGraph();
     const info = { graph, breaks: [], nexts: [], returns: [], exitPoints: [node.info.id + '-exit'], entryPoints: [node.info.id] };
-    graph.addVertex({ id: node.info.id, name: node.type });
+    graph.addVertex({ id: node.info.id, name: node.type, type: "expression" /* CfgVertexType.Expression */ });
     let currentExitPoint = [node.info.id];
     if (name) {
         graph.merge(name.graph);
@@ -309,7 +314,7 @@ function cfgArgumentOrParameter(node, name, value) {
         }
         currentExitPoint = name.exitPoints;
     }
-    graph.addVertex({ id: node.info.id + '-before-value', name: 'before-value' });
+    graph.addVertex({ id: node.info.id + '-before-value', name: 'before-value', type: "mid-marker" /* CfgVertexType.MidMarker */ });
     for (const exitPoints of currentExitPoint) {
         graph.addEdge(node.info.id + '-before-value', exitPoints, { label: 'FD' });
     }
@@ -326,7 +331,7 @@ function cfgArgumentOrParameter(node, name, value) {
         }
         currentExitPoint = value.exitPoints;
     }
-    graph.addVertex({ id: node.info.id + '-exit', name: 'exit' });
+    graph.addVertex({ id: node.info.id + '-exit', name: 'exit', type: "end-marker" /* CfgVertexType.EndMarker */ });
     for (const exit of currentExitPoint) {
         graph.addEdge(node.info.id + '-exit', exit, { label: 'FD' });
     }
@@ -335,8 +340,8 @@ function cfgArgumentOrParameter(node, name, value) {
 function cfgBinaryOp(binOp, lhs, rhs) {
     const graph = new ControlFlowGraph().merge(lhs.graph).merge(rhs.graph);
     const result = { graph, breaks: [...lhs.breaks, ...rhs.breaks], nexts: [...lhs.nexts, ...rhs.nexts], returns: [...lhs.returns, ...rhs.returns], entryPoints: [binOp.info.id], exitPoints: [binOp.info.id + '-exit'] };
-    graph.addVertex({ id: binOp.info.id, name: binOp.type });
-    graph.addVertex({ id: binOp.info.id + '-exit', name: 'binOp-exit' });
+    graph.addVertex({ id: binOp.info.id, name: binOp.type, type: binOp.flavor === 'assignment' ? "statement" /* CfgVertexType.Statement */ : "expression" /* CfgVertexType.Expression */ });
+    graph.addVertex({ id: binOp.info.id + '-exit', name: 'binOp-exit', type: "end-marker" /* CfgVertexType.EndMarker */ });
     for (const exitPoint of lhs.exitPoints) {
         for (const entryPoint of rhs.entryPoints) {
             result.graph.addEdge(entryPoint, exitPoint, { label: 'FD' });
@@ -353,8 +358,8 @@ function cfgBinaryOp(binOp, lhs, rhs) {
 function cfgAccess(access, name, accessors) {
     const result = name;
     const graph = result.graph;
-    graph.addVertex({ id: access.info.id, name: access.type });
-    graph.addVertex({ id: access.info.id + '-exit', name: 'access-exit' });
+    graph.addVertex({ id: access.info.id, name: access.type, type: "expression" /* CfgVertexType.Expression */ });
+    graph.addVertex({ id: access.info.id + '-exit', name: 'access-exit', type: "end-marker" /* CfgVertexType.EndMarker */ });
     for (const entry of name.entryPoints) {
         graph.addEdge(entry, access.info.id, { label: 'FD' });
     }
@@ -383,7 +388,7 @@ function cfgAccess(access, name, accessors) {
 function cfgUnaryOp(unary, operand) {
     const graph = operand.graph;
     const result = { ...operand, graph, exitPoints: [unary.info.id] };
-    graph.addVertex({ id: unary.info.id, name: unary.type });
+    graph.addVertex({ id: unary.info.id, name: unary.type, type: "end-marker" /* CfgVertexType.EndMarker */ });
     return result;
 }
 function cfgExprList(_node, expressions) {

package/util/cfg/visitor.d.ts

@@ -0,0 +1,14 @@
+import type { NodeId } from '../../r-bridge';
+import type { CfgEdge, CfgVertex, ControlFlowInformation } from './cfg';
+export interface NodeVisitingContext {
+    parent: {
+        vertex: NodeId;
+        edge: CfgEdge;
+    } | 'root';
+    cfg: ControlFlowInformation;
+    visited: Set<NodeId>;
+    /** contains the current vertex as well */
+    siblings: NodeId[];
+}
+export type OnEnterVisitNode = (node: CfgVertex, context: NodeVisitingContext) => void;
+export declare function visitCfg(cfg: ControlFlowInformation, onVisit: OnEnterVisitNode): void;

package/util/cfg/visitor.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.visitCfg = void 0;
+const assert_1 = require("../assert");
+class ControlFlowGraphExecutionTraceVisitor {
+    onEnter;
+    constructor(onEnter) {
+        this.onEnter = onEnter;
+    }
+    visitSingle(node, context) {
+        if (context.visited.has(node.id)) {
+            return;
+        }
+        // only visit a node if we have visited all of its successors
+        const successorEdges = context.cfg.graph.edges().get(node.id);
+        if (successorEdges) {
+            for (const [target,] of successorEdges) {
+                if (!context.visited.has(target)) {
+                    return;
+                }
+            }
+        }
+        context.visited.add(node.id);
+        this.onEnter(node, context);
+        // find all ingoing edges
+        const predecessors = this.retrieveAllPredecessors(context, node);
+        const siblings = predecessors.map(p => p.source);
+        for (const predecessor of predecessors) {
+            const { source, edge } = predecessor;
+            const sourceVertex = context.cfg.graph.vertices().get(source);
+            (0, assert_1.guard)(sourceVertex !== undefined, () => `Source vertex with id ${source} not found`);
+            this.visitSingle(sourceVertex, {
+                parent: { vertex: node.id, edge },
+                cfg: context.cfg,
+                visited: context.visited,
+                siblings
+            });
+        }
+    }
+    retrieveAllPredecessors(context, node) {
+        const predecessors = [];
+        for (const entry of context.cfg.graph.edges().entries()) {
+            const [source, targets] = entry;
+            const target = targets.get(node.id);
+            if (target) {
+                predecessors.push({ source, edge: target });
+            }
+        }
+        return predecessors;
+    }
+    visit(cfg) {
+        const visited = new Set;
+        for (const id of cfg.entryPoints) {
+            const node = cfg.graph.vertices().get(id);
+            (0, assert_1.guard)(node !== undefined, `Node with id ${id} not present`);
+            this.visitSingle(node, { parent: 'root', cfg, siblings: [...cfg.entryPoints], visited });
+        }
+    }
+}
+function visitCfg(cfg, onVisit) {
+    return new ControlFlowGraphExecutionTraceVisitor(onVisit).visit(cfg);
+}
+exports.visitCfg = visitCfg;
+//# sourceMappingURL=visitor.js.map