@eagleoutice/flowr 2.2.0 → 2.2.1

package/dataflow/environments/resolve-by-name.js

@@ -7,6 +7,7 @@ exports.getAliases = getAliases;
 exports.resolveToValues = resolveToValues;
 exports.resolveValueOfVariable = resolveValueOfVariable;
 const environment_1 = require("./environment");
+const logic_1 = require("../../util/logic");
 const identifier_1 = require("./identifier");
 const info_1 = require("../info");
 const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
@@ -66,11 +67,11 @@ function resolveByName(name, environment, target = identifier_1.ReferenceType.Un
 }
 function resolvesToBuiltInConstant(name, environment, wantedValue) {
     if (name === undefined) {
-        return 2 /* Ternary.Never */;
+        return logic_1.Ternary.Never;
     }
     const definition = resolveByName(name, environment, identifier_1.ReferenceType.Constant);
     if (definition === undefined) {
-        return 2 /* Ternary.Never */;
+        return logic_1.Ternary.Never;
     }
     let all = true;
     let some = false;
@@ -83,10 +84,10 @@ function resolvesToBuiltInConstant(name, environment, wantedValue) {
         }
     }
     if (all) {
-        return 0 /* Ternary.Always */;
+        return logic_1.Ternary.Always;
     }
     else {
-        return some ? 1 /* Ternary.Maybe */ : 2 /* Ternary.Never */;
+        return some ? logic_1.Ternary.Maybe : logic_1.Ternary.Never;
     }
 }
 function resolveToConstants(name, environment) {

package/documentation/print-query-wiki.js

@@ -213,6 +213,30 @@ ${await (0, doc_query_1.showQuery)(shell, exampleCode, [{
 		`;
     }
 });
+(0, doc_query_1.registerQueryDocumentation)('happens-before', {
+    name: 'Happens-Before Query',
+    type: 'active',
+    shortDescription: 'Check whether one normalized AST node happens before another in the CFG.',
+    functionName: search_query_executor_1.executeSearch.name,
+    functionFile: '../queries/catalog/happens-before-query/happens-before-query-executor.ts',
+    buildExplanation: async (shell) => {
+        const exampleCode = 'x <- 1\ny <- 2';
+        return `
+With this query you can analyze the control flow graph:
+
+Using the example code:
+
+${(0, doc_code_1.codeBlock)('r', exampleCode)}
+
+the following query returns that the first assignment happens always before the other:
+${await (0, doc_query_1.showQuery)(shell, exampleCode, [{
+                type: 'happens-before',
+                a: '1@x',
+                b: '2@y'
+            }], { showCode: true, collapseQuery: false })}
+		`;
+    }
+});
 (0, doc_query_1.registerQueryDocumentation)('id-map', {
     name: 'Id-Map Query',
     type: 'active',

package/package.json

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

package/queries/catalog/happens-before-query/happens-before-query-executor.d.ts

@@ -0,0 +1,3 @@
+import type { BasicQueryData } from '../../base-query-format';
+import type { HappensBeforeQuery, HappensBeforeQueryResult } from './happens-before-query-format';
+export declare function executeHappensBefore({ ast }: BasicQueryData, queries: readonly HappensBeforeQuery[]): HappensBeforeQueryResult;

package/queries/catalog/happens-before-query/happens-before-query-executor.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeHappensBefore = executeHappensBefore;
+const logic_1 = require("../../../util/logic");
+const log_1 = require("../../../util/log");
+const cfg_1 = require("../../../util/cfg/cfg");
+const happens_before_1 = require("../../../util/cfg/happens-before");
+const parse_1 = require("../../../slicing/criterion/parse");
+function executeHappensBefore({ ast }, queries) {
+    const start = Date.now();
+    const results = {};
+    const cfg = (0, cfg_1.extractCFG)(ast);
+    for (const query of queries) {
+        const { a, b } = query;
+        const fingerprint = `${a}<${b}`;
+        if (fingerprint in results) {
+            log_1.log.warn('Duplicate happens-before query', query, 'ignoring');
+        }
+        try {
+            const resolvedA = (0, parse_1.slicingCriterionToId)(a, ast.idMap);
+            const resolvedB = (0, parse_1.slicingCriterionToId)(b, ast.idMap);
+            results[fingerprint] = (0, happens_before_1.happensBefore)(cfg.graph, resolvedA, resolvedB);
+        }
+        catch (e) {
+            log_1.log.error('Error while executing happens-before query', query, e);
+            results[fingerprint] = logic_1.Ternary.Maybe;
+        }
+    }
+    return {
+        '.meta': {
+            timing: Date.now() - start
+        },
+        results
+    };
+}
+//# sourceMappingURL=happens-before-query-executor.js.map

package/queries/catalog/happens-before-query/happens-before-query-format.d.ts

@@ -0,0 +1,71 @@
+import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
+import Joi from 'joi';
+import { executeHappensBefore } from './happens-before-query-executor';
+import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
+import type { Ternary } from '../../../util/logic';
+export interface HappensBeforeQuery extends BaseQueryFormat {
+    readonly type: 'happens-before';
+    readonly a: SingleSlicingCriterion;
+    readonly b: SingleSlicingCriterion;
+}
+export interface HappensBeforeQueryResult extends BaseQueryResult {
+    readonly results: Record<string, Ternary>;
+}
+export declare const HappensBeforeQueryDefinition: {
+    readonly executor: typeof executeHappensBefore;
+    readonly asciiSummarizer: (formatter: import("../../../util/ansi").OutputFormatter, _processed: import("../../../core/steps/pipeline/pipeline").PipelineOutput<import("../../../core/steps/pipeline/pipeline").Pipeline<{
+        readonly name: "parse";
+        readonly humanReadableName: "parse with R shell";
+        readonly description: "Parse the given R code into an AST";
+        readonly processor: (_results: unknown, input: Partial<import("../../../r-bridge/parser").ParseRequiredInput<string>>) => Promise<import("../../../r-bridge/parser").ParseStepOutput<string>>;
+        readonly executed: import("../../../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+        readonly printer: {
+            readonly 0: typeof import("../../../core/print/print").internalPrinter;
+            readonly 2: {
+                (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+                (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+            };
+            readonly 5: ({ parsed }: import("../../../r-bridge/parser").ParseStepOutput<string>, config: import("../../../util/quads").QuadSerializationConfiguration) => string;
+        };
+        readonly dependencies: readonly [];
+        readonly requiredInput: import("../../../r-bridge/parser").ParseRequiredInput<string>;
+    } | {
+        readonly name: "normalize";
+        readonly humanReadableName: "normalize";
+        readonly description: "Normalize the AST to flowR's AST";
+        readonly processor: (results: {
+            parse?: import("../../../r-bridge/parser").ParseStepOutput<string>;
+        }, input: Partial<import("../../../core/steps/all/core/10-normalize").NormalizeRequiredInput>) => import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
+        readonly executed: import("../../../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+        readonly printer: {
+            readonly 0: typeof import("../../../core/print/print").internalPrinter;
+            readonly 2: typeof import("../../../core/print/normalize-printer").normalizedAstToJson;
+            readonly 5: typeof import("../../../core/print/normalize-printer").normalizedAstToQuads;
+            readonly 3: typeof import("../../../core/print/normalize-printer").printNormalizedAstToMermaid;
+            readonly 4: typeof import("../../../core/print/normalize-printer").printNormalizedAstToMermaidUrl;
+        };
+        readonly dependencies: readonly ["parse"];
+        readonly requiredInput: import("../../../core/steps/all/core/10-normalize").NormalizeRequiredInput;
+    } | {
+        readonly humanReadableName: "dataflow";
+        readonly processor: (results: {
+            normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+        }, input: {
+            request?: import("../../../r-bridge/retriever").RParseRequests;
+            parser?: import("../../../r-bridge/parser").Parser<import("../../../r-bridge/parser").KnownParserType>;
+        }) => import("../../../dataflow/info").DataflowInformation;
+        readonly requiredInput: {};
+        readonly name: "dataflow";
+        readonly description: "Construct the dataflow graph";
+        readonly executed: import("../../../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+        readonly printer: {
+            readonly 0: typeof import("../../../core/print/print").internalPrinter;
+            readonly 2: typeof import("../../../core/print/dataflow-printer").dataflowGraphToJson;
+            readonly 5: typeof import("../../../core/print/dataflow-printer").dataflowGraphToQuads;
+            readonly 3: typeof import("../../../core/print/dataflow-printer").dataflowGraphToMermaid;
+            readonly 4: typeof import("../../../core/print/dataflow-printer").dataflowGraphToMermaidUrl;
+        };
+        readonly dependencies: readonly ["normalize"];
+    }>>, queryResults: BaseQueryResult, result: string[]) => true;
+    readonly schema: Joi.ObjectSchema<any>;
+};

package/queries/catalog/happens-before-query/happens-before-query-format.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HappensBeforeQueryDefinition = void 0;
+const ansi_1 = require("../../../util/ansi");
+const time_1 = require("../../../util/time");
+const joi_1 = __importDefault(require("joi"));
+const happens_before_query_executor_1 = require("./happens-before-query-executor");
+exports.HappensBeforeQueryDefinition = {
+    executor: happens_before_query_executor_1.executeHappensBefore,
+    asciiSummarizer: (formatter, _processed, queryResults, result) => {
+        const out = queryResults;
+        result.push(`Query: ${(0, ansi_1.bold)('happens-before', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
+        for (const [key, value] of Object.entries(out.results)) {
+            result.push(`   ╰ ${key}: ${value}`);
+        }
+        return true;
+    },
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('happens-before').required().description('The type of the query.'),
+        a: joi_1.default.string().required().description('The first slicing criterion.'),
+        b: joi_1.default.string().required().description('The second slicing criterion.')
+    }).description('The id map query retrieves the id map from the normalized AST.')
+};
+//# sourceMappingURL=happens-before-query-format.js.map

package/queries/catalog/search-query/search-query-executor.js

@@ -1,13 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeSearch = executeSearch;
-const log_1 = require("../../../util/log");
 const flowr_search_executor_1 = require("../../../search/flowr-search-executor");
 function executeSearch({ ast, dataflow }, queries) {
     const start = Date.now();
-    if (queries.length !== 1) {
-        log_1.log.warn('Id-Map query expects only up to one query, but got', queries.length);
-    }
     const results = [];
     for (const query of queries) {
         const { search } = query;

package/queries/query.d.ts

@@ -16,7 +16,8 @@ import Joi from 'joi';
 import type { LocationMapQuery } from './catalog/location-map-query/location-map-query-format';
 import type { ConfigQuery } from './catalog/config-query/config-query-format';
 import type { SearchQuery } from './catalog/search-query/search-query-format';
-export type Query = CallContextQuery | ConfigQuery | SearchQuery | DataflowQuery | NormalizedAstQuery | IdMapQuery | DataflowClusterQuery | StaticSliceQuery | LineageQuery | DependenciesQuery | LocationMapQuery;
+import type { HappensBeforeQuery } from './catalog/happens-before-query/happens-before-query-format';
+export type Query = CallContextQuery | ConfigQuery | SearchQuery | DataflowQuery | NormalizedAstQuery | IdMapQuery | DataflowClusterQuery | StaticSliceQuery | LineageQuery | DependenciesQuery | LocationMapQuery | HappensBeforeQuery;
 export type QueryArgumentsWithType<QueryType extends BaseQueryFormat['type']> = Query & {
     type: QueryType;
 };
@@ -509,6 +510,64 @@ export declare const SupportedQueries: {
         }>>, queryResults: BaseQueryResult, result: string[]) => true;
         readonly schema: Joi.ObjectSchema<any>;
     };
+    readonly 'happens-before': {
+        readonly executor: typeof import("./catalog/happens-before-query/happens-before-query-executor").executeHappensBefore;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _processed: PipelineOutput<import("../core/steps/pipeline/pipeline").Pipeline<{
+            readonly name: "parse";
+            readonly humanReadableName: "parse with R shell";
+            readonly description: "Parse the given R code into an AST";
+            readonly processor: (_results: unknown, input: Partial<import("../r-bridge/parser").ParseRequiredInput<string>>) => Promise<import("../r-bridge/parser").ParseStepOutput<string>>;
+            readonly executed: import("../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+            readonly printer: {
+                readonly 0: typeof import("../core/print/print").internalPrinter;
+                readonly 2: {
+                    (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+                    (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+                };
+                readonly 5: ({ parsed }: import("../r-bridge/parser").ParseStepOutput<string>, config: import("../util/quads").QuadSerializationConfiguration) => string;
+            };
+            readonly dependencies: readonly [];
+            readonly requiredInput: import("../r-bridge/parser").ParseRequiredInput<string>;
+        } | {
+            readonly name: "normalize";
+            readonly humanReadableName: "normalize";
+            readonly description: "Normalize the AST to flowR's AST";
+            readonly processor: (results: {
+                parse?: import("../r-bridge/parser").ParseStepOutput<string>;
+            }, input: Partial<import("../core/steps/all/core/10-normalize").NormalizeRequiredInput>) => import("../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../r-bridge/lang-4.x/ast/model/model").RNode<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
+            readonly executed: import("../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+            readonly printer: {
+                readonly 0: typeof import("../core/print/print").internalPrinter;
+                readonly 2: typeof import("../core/print/normalize-printer").normalizedAstToJson;
+                readonly 5: typeof import("../core/print/normalize-printer").normalizedAstToQuads;
+                readonly 3: typeof import("../core/print/normalize-printer").printNormalizedAstToMermaid;
+                readonly 4: typeof import("../core/print/normalize-printer").printNormalizedAstToMermaidUrl;
+            };
+            readonly dependencies: readonly ["parse"];
+            readonly requiredInput: import("../core/steps/all/core/10-normalize").NormalizeRequiredInput;
+        } | {
+            readonly humanReadableName: "dataflow";
+            readonly processor: (results: {
+                normalize?: import("../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+            }, input: {
+                request?: import("../r-bridge/retriever").RParseRequests;
+                parser?: import("../r-bridge/parser").Parser<import("../r-bridge/parser").KnownParserType>;
+            }) => import("../dataflow/info").DataflowInformation;
+            readonly requiredInput: {};
+            readonly name: "dataflow";
+            readonly description: "Construct the dataflow graph";
+            readonly executed: import("../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+            readonly printer: {
+                readonly 0: typeof import("../core/print/print").internalPrinter;
+                readonly 2: typeof import("../core/print/dataflow-printer").dataflowGraphToJson;
+                readonly 5: typeof import("../core/print/dataflow-printer").dataflowGraphToQuads;
+                readonly 3: typeof import("../core/print/dataflow-printer").dataflowGraphToMermaid;
+                readonly 4: typeof import("../core/print/dataflow-printer").dataflowGraphToMermaidUrl;
+            };
+            readonly dependencies: readonly ["normalize"];
+        }>>, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly schema: Joi.ObjectSchema<any>;
+    };
 };
 export type SupportedQueryTypes = keyof typeof SupportedQueries;
 export type QueryResult<Type extends Query['type']> = ReturnType<typeof SupportedQueries[Type]['executor']>;

package/queries/query.js

@@ -24,6 +24,7 @@ const joi_1 = __importDefault(require("joi"));
 const location_map_query_format_1 = require("./catalog/location-map-query/location-map-query-format");
 const config_query_format_1 = require("./catalog/config-query/config-query-format");
 const search_query_format_1 = require("./catalog/search-query/search-query-format");
+const happens_before_query_format_1 = require("./catalog/happens-before-query/happens-before-query-format");
 exports.SupportedQueries = {
     'call-context': call_context_query_format_1.CallContextQueryDefinition,
     'config': config_query_format_1.ConfigQueryDefinition,
@@ -35,7 +36,8 @@ exports.SupportedQueries = {
     'lineage': lineage_query_format_1.LineageQueryDefinition,
     'dependencies': dependencies_query_format_1.DependenciesQueryDefinition,
     'location-map': location_map_query_format_1.LocationMapQueryDefinition,
-    'search': search_query_format_1.SearchQueryDefinition
+    'search': search_query_format_1.SearchQueryDefinition,
+    'happens-before': happens_before_query_format_1.HappensBeforeQueryDefinition
 };
 function executeQueriesOfSameType(data, ...queries) {
     (0, assert_1.guard)(queries.length > 0, 'At least one query must be provided');

package/util/cfg/cfg.d.ts

@@ -25,6 +25,8 @@ interface CfgFlowDependencyEdge extends MergeableRecord {
 }
 interface CfgControlDependencyEdge extends MergeableRecord {
     label: 'CD';
+    /** the id which caused the control dependency */
+    caused: NodeId;
     when: typeof RTrue | typeof RFalse;
 }
 export type CfgEdge = CfgFlowDependencyEdge | CfgControlDependencyEdge;

package/util/cfg/cfg.js

@@ -134,10 +134,10 @@ function cfgIfThenElse(ifNode, condition, then, otherwise) {
     }
     for (const exitPoint of condition.exitPoints) {
         for (const entryPoint of then.entryPoints) {
-            graph.addEdge(entryPoint, exitPoint, { label: 'CD', when: convert_values_1.RTrue });
+            graph.addEdge(entryPoint, exitPoint, { label: 'CD', when: convert_values_1.RTrue, caused: ifNode.info.id });
         }
         for (const entryPoint of otherwise?.entryPoints ?? []) {
-            graph.addEdge(entryPoint, exitPoint, { label: 'CD', when: convert_values_1.RFalse });
+            graph.addEdge(entryPoint, exitPoint, { label: 'CD', when: convert_values_1.RFalse, caused: ifNode.info.id });
         }
     }
     for (const entryPoint of condition.entryPoints) {
@@ -148,7 +148,7 @@ function cfgIfThenElse(ifNode, condition, then, otherwise) {
     }
     if (!otherwise) {
         for (const exitPoint of condition.exitPoints) {
-            graph.addEdge(ifNode.info.id + '-exit', exitPoint, { label: 'CD', when: convert_values_1.RFalse });
+            graph.addEdge(ifNode.info.id + '-exit', exitPoint, { label: 'CD', when: convert_values_1.RFalse, caused: ifNode.info.id });
         }
     }
     return {
@@ -165,7 +165,7 @@ function cfgRepeat(repeat, body) {
     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' });
+        graph.addEdge(entryPoint, repeat.info.id, { label: 'FD' });
     }
     // loops automatically
     for (const next of [...body.nexts, ...body.exitPoints]) {
@@ -186,7 +186,7 @@ function cfgWhile(whileLoop, condition, body) {
     }
     for (const exit of condition.exitPoints) {
         for (const entry of body.entryPoints) {
-            graph.addEdge(entry, exit, { label: 'CD', when: convert_values_1.RTrue });
+            graph.addEdge(entry, exit, { label: 'CD', when: convert_values_1.RTrue, caused: whileLoop.info.id });
         }
     }
     for (const entryPoint of body.entryPoints) {
@@ -200,7 +200,7 @@ function cfgWhile(whileLoop, condition, body) {
     }
     // while can break on the condition as well
     for (const exit of condition.exitPoints) {
-        graph.addEdge(whileLoop.info.id + '-exit', exit, { label: 'CD', when: convert_values_1.RFalse });
+        graph.addEdge(whileLoop.info.id + '-exit', exit, { label: 'CD', when: convert_values_1.RFalse, caused: whileLoop.info.id });
     }
     return { graph, breaks: [], nexts: [], returns: body.returns, exitPoints: [whileLoop.info.id + '-exit'], entryPoints: [whileLoop.info.id] };
 }
@@ -220,7 +220,7 @@ function cfgFor(forLoop, variable, vector, body) {
     }
     for (const exit of variable.exitPoints) {
         for (const entry of body.entryPoints) {
-            graph.addEdge(entry, exit, { label: 'CD', when: convert_values_1.RTrue });
+            graph.addEdge(entry, exit, { label: 'CD', when: convert_values_1.RTrue, caused: forLoop.info.id });
         }
     }
     for (const next of [...body.nexts, ...body.exitPoints]) {
@@ -231,7 +231,7 @@ function cfgFor(forLoop, variable, vector, body) {
     }
     // while can break on the condition as well
     for (const exit of variable.exitPoints) {
-        graph.addEdge(forLoop.info.id + '-exit', exit, { label: 'CD', when: convert_values_1.RFalse });
+        graph.addEdge(forLoop.info.id + '-exit', exit, { label: 'CD', when: convert_values_1.RFalse, caused: forLoop.info.id });
     }
     return { graph, breaks: [], nexts: [], returns: body.returns, exitPoints: [forLoop.info.id + '-exit'], entryPoints: [forLoop.info.id] };
 }

package/util/cfg/happens-before.d.ts

@@ -0,0 +1,7 @@
+import type { ControlFlowGraph } from './cfg';
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { Ternary } from '../logic';
+/**
+ * Determines if node `a` happens before node `b` in the control flow graph.
+ */
+export declare function happensBefore(cfg: ControlFlowGraph, a: NodeId, b: NodeId): Ternary;

package/util/cfg/happens-before.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.happensBefore = happensBefore;
+const logic_1 = require("../logic");
+/**
+ * Determines if node `a` happens before node `b` in the control flow graph.
+ */
+function happensBefore(cfg, a, b) {
+    const visited = new Set();
+    /* the first is the id we are currently at, the second one the exit marker of the current largest cd scope */
+    const stack = [[b, undefined]];
+    while (stack.length > 0) {
+        const [current, cd] = stack.pop();
+        let useCd = cd;
+        if (current === a) {
+            return cd ? logic_1.Ternary.Maybe : logic_1.Ternary.Always;
+        }
+        else if (visited.has(current)) {
+            continue;
+        }
+        else if (cd && (current === cd || visited.has(cd))) {
+            useCd = undefined;
+        }
+        visited.add(current);
+        for (const [id, t] of cfg.outgoing(current) ?? []) {
+            const marker = t.label === 'CD' ? `${t.caused}-exit` : useCd;
+            stack.push([id, useCd ?? marker]);
+        }
+    }
+    return logic_1.Ternary.Never;
+}
+//# sourceMappingURL=happens-before.js.map

package/util/logic.d.ts

@@ -1,5 +1,5 @@
-export declare const enum Ternary {
-    Always = 0,
-    Maybe = 1,
-    Never = 2
+export declare enum Ternary {
+    Always = "always",
+    Maybe = "maybe",
+    Never = "never"
 }

package/util/logic.js

@@ -1,3 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ternary = void 0;
+// diverging from boolean | maybe requires explicit handling
+var Ternary;
+(function (Ternary) {
+    Ternary["Always"] = "always";
+    Ternary["Maybe"] = "maybe";
+    Ternary["Never"] = "never";
+})(Ternary || (exports.Ternary = Ternary = {}));
 //# sourceMappingURL=logic.js.map

package/util/version.js

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