@eagleoutice/flowr 1.3.11

package/dataflow/environments/environment.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloneEnvironments = exports.diffEnvironments = exports.diffEnvironment = exports.initializeCleanEnvironments = exports.DefaultEnvironmentMemory = exports.Environment = exports.makeAllMaybe = exports.diffIdentifierReferences = exports.BuiltIn = void 0;
+const resolve_by_name_1 = require("./resolve-by-name");
+const scopes_1 = require("./scopes");
+const diff_1 = require("../../util/diff");
+const json_1 = require("../../util/json");
+exports.BuiltIn = 'built-in';
+function diffIdentifierReferences(a, b, info) {
+    if (a.name !== b.name) {
+        info.report.addComment(`${info.position}Different identifier names: ${a.name} vs. ${b.name}`);
+    }
+    if (a.scope !== b.scope) {
+        info.report.addComment(`${info.position}Different scopes: ${a.scope} vs. ${b.scope}`);
+    }
+    if (a.nodeId !== b.nodeId) {
+        info.report.addComment(`${info.position}Different nodeIds: ${a.nodeId} vs. ${b.nodeId}`);
+    }
+    if (a.used !== b.used) {
+        info.report.addComment(`${info.position}Different used: ${a.used} vs. ${b.used}`);
+    }
+}
+exports.diffIdentifierReferences = diffIdentifierReferences;
+function makeAllMaybe(references, graph, environments) {
+    if (references === undefined) {
+        return [];
+    }
+    return references.map(ref => {
+        const node = graph.get(ref.nodeId, true);
+        const definitions = (0, resolve_by_name_1.resolveByName)(ref.name, scopes_1.LocalScope, environments);
+        for (const definition of definitions ?? []) {
+            if (definition.kind !== 'built-in-function') {
+                definition.used = 'maybe';
+            }
+        }
+        if (node) {
+            node[0].when = 'maybe';
+        }
+        return { ...ref, used: 'maybe' };
+    });
+}
+exports.makeAllMaybe = makeAllMaybe;
+let environmentIdCounter = 0;
+class Environment {
+    name;
+    id = `${environmentIdCounter++}`;
+    parent;
+    memory;
+    constructor(name, parent) {
+        this.name = name;
+        this.parent = parent;
+        this.memory = new Map();
+    }
+}
+exports.Environment = Environment;
+exports.DefaultEnvironmentMemory = new Map([
+    ['return', [{
+                kind: 'built-in-function',
+                scope: scopes_1.GlobalScope,
+                used: 'always',
+                definedAt: exports.BuiltIn,
+                name: 'return',
+                nodeId: exports.BuiltIn
+            }]],
+    ['cat', [{
+                kind: 'built-in-function',
+                scope: scopes_1.GlobalScope,
+                used: 'always',
+                definedAt: exports.BuiltIn,
+                name: 'cat',
+                nodeId: exports.BuiltIn
+            }]],
+    ['print', [{
+                kind: 'built-in-function',
+                scope: scopes_1.GlobalScope,
+                used: 'always',
+                definedAt: exports.BuiltIn,
+                name: 'print',
+                nodeId: exports.BuiltIn
+            }]]
+]);
+function initializeCleanEnvironments() {
+    const global = new Environment(scopes_1.GlobalScope);
+    // use a copy
+    global.memory = new Map(exports.DefaultEnvironmentMemory);
+    return {
+        current: global,
+        level: 0
+    };
+}
+exports.initializeCleanEnvironments = initializeCleanEnvironments;
+function diffEnvironment(a, b, info) {
+    if (a === undefined || b === undefined) {
+        if (a !== b) {
+            info.report.addComment(`${info.position}Different environments. ${info.leftname}: ${JSON.stringify(a, json_1.jsonReplacer)} vs. ${info.rightname}: ${JSON.stringify(b, json_1.jsonReplacer)}`);
+        }
+        return;
+    }
+    if (a.name !== b.name) {
+        info.report.addComment(`${info.position}Different environment names. ${info.leftname}: ${JSON.stringify(a, json_1.jsonReplacer)} vs. ${info.rightname}: ${JSON.stringify(b, json_1.jsonReplacer)}`);
+    }
+    if (a.memory.size !== b.memory.size) {
+        info.report.addComment(`${info.position}Different environment sizes. ${info.leftname}: ${JSON.stringify(a, json_1.jsonReplacer)} vs. ${info.rightname}: ${JSON.stringify(b, json_1.jsonReplacer)}`);
+        (0, diff_1.setDifference)(new Set([...a.memory.keys()]), new Set([...b.memory.keys()]), { ...info, position: `${info.position}Key comparison. ` });
+    }
+    for (const [key, value] of a.memory) {
+        const value2 = b.memory.get(key);
+        if (value2 === undefined || value.length !== value2.length) {
+            info.report.addComment(`${info.position}Different definitions for ${key}. ${info.leftname}: ${JSON.stringify(value, json_1.jsonReplacer)} vs. ${info.rightname}: ${JSON.stringify(value2, json_1.jsonReplacer)}`);
+            continue;
+        }
+        for (let i = 0; i < value.length; ++i) {
+            const aVal = value[i];
+            const bVal = value2[i];
+            if (aVal.name !== bVal.name) {
+                info.report.addComment(`${info.position}Different names for ${key}. ${info.leftname}: ${aVal.name} vs. ${info.rightname}: ${bVal.name}`);
+            }
+            if (aVal.nodeId !== bVal.nodeId) {
+                info.report.addComment(`${info.position}Different ids for ${key}. ${info.leftname}: ${aVal.nodeId} vs. ${info.rightname}: ${bVal.nodeId}`);
+            }
+            if (aVal.scope !== bVal.scope) {
+                info.report.addComment(`${info.position}Different scopes for ${key}. ${info.leftname}: ${aVal.scope} vs. ${info.rightname}: ${bVal.scope}`);
+            }
+            if (aVal.used !== bVal.used) {
+                info.report.addComment(`${info.position}Different used for ${key}. ${info.leftname}: ${aVal.used} vs. ${info.rightname}: ${bVal.used}`);
+            }
+            if (aVal.definedAt !== bVal.definedAt) {
+                info.report.addComment(`${info.position}Different definition ids (definedAt) for ${key}. ${info.leftname}: ${aVal.definedAt} vs. ${info.rightname}: ${bVal.definedAt}`);
+            }
+            if (aVal.kind !== bVal.kind) {
+                info.report.addComment(`${info.position}Different kinds for ${key}. ${info.leftname}: ${aVal.kind} vs. ${info.rightname}: ${bVal.kind}`);
+            }
+        }
+    }
+    diffEnvironment(a.parent, b.parent, { ...info, position: `${info.position}Parents of ${a.id} & ${b.id}. ` });
+}
+exports.diffEnvironment = diffEnvironment;
+function diffEnvironments(a, b, info) {
+    if (a === undefined || b === undefined) {
+        info.report.addComment(`${info.position}Different environments: ${JSON.stringify(a, json_1.jsonReplacer)} vs. ${JSON.stringify(b, json_1.jsonReplacer)}`);
+        return;
+    }
+    diffEnvironment(a.current, b.current, info);
+}
+exports.diffEnvironments = diffEnvironments;
+function cloneEnvironment(environment, recurseParents) {
+    if (environment === undefined) {
+        return undefined;
+    }
+    const clone = new Environment(environment.name, recurseParents ? cloneEnvironment(environment.parent, recurseParents) : environment.parent);
+    clone.memory = new Map(JSON.parse(JSON.stringify([...environment.memory])));
+    return clone;
+}
+function cloneEnvironments(environment, recurseParents = true) {
+    return {
+        current: cloneEnvironment(environment.current, recurseParents),
+        level: environment.level
+    };
+}
+exports.cloneEnvironments = cloneEnvironments;
+//# sourceMappingURL=environment.js.map

package/dataflow/environments/index.d.ts

@@ -0,0 +1,7 @@
+export * from './append';
+export * from './resolve-by-name';
+export * from './scoping';
+export * from './overwrite';
+export * from './environment';
+export * from './register';
+export { DataflowScopeName } from './scopes';

package/dataflow/environments/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./append"), exports);
+__exportStar(require("./resolve-by-name"), exports);
+__exportStar(require("./scoping"), exports);
+__exportStar(require("./overwrite"), exports);
+__exportStar(require("./environment"), exports);
+__exportStar(require("./register"), exports);
+//# sourceMappingURL=index.js.map

package/dataflow/environments/overwrite.d.ts

@@ -0,0 +1,6 @@
+import { REnvironmentInformation, IEnvironment } from './environment';
+export declare function overwriteIEnvironmentWith(base: IEnvironment | undefined, next: IEnvironment | undefined, includeParent?: boolean): IEnvironment;
+export declare function overwriteEnvironments(base: REnvironmentInformation, next: REnvironmentInformation | undefined): REnvironmentInformation;
+export declare function overwriteEnvironments(base: REnvironmentInformation | undefined, next: REnvironmentInformation): REnvironmentInformation;
+export declare function overwriteEnvironments(base: undefined, next: undefined): undefined;
+export declare function overwriteEnvironments(base: REnvironmentInformation | undefined, next: REnvironmentInformation | undefined): REnvironmentInformation | undefined;

package/dataflow/environments/overwrite.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.overwriteEnvironments = exports.overwriteIEnvironmentWith = void 0;
+const assert_1 = require("../../util/assert");
+const environment_1 = require("./environment");
+function anyIsMaybeGuardingSame(values) {
+    if (values.length === 0) {
+        return true;
+    }
+    const attr = values[0].used;
+    if (attr === 'maybe') {
+        return true;
+    }
+    let same = true;
+    for (let i = 1; i < values.length; i++) {
+        const used = values[i].used;
+        if (used === 'maybe') {
+            return true;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- in case we want to add more attributes in the future
+        if (used !== attr) {
+            same = false;
+        }
+    }
+    if (!same) {
+        throw new Error('all values must have either a maybe or are all the same');
+    }
+    return false;
+}
+function overwriteIEnvironmentWith(base, next, includeParent = true) {
+    (0, assert_1.guard)(base !== undefined && next !== undefined, 'can not overwrite environments with undefined');
+    (0, assert_1.guard)(base.name === next.name, 'cannot overwrite environments with different names');
+    const map = new Map(base.memory);
+    for (const [key, values] of next.memory) {
+        const hasMaybe = anyIsMaybeGuardingSame(values);
+        if (hasMaybe) {
+            const old = map.get(key);
+            // we need to make a copy to avoid side effects for old reference in other environments
+            const updatedOld = old ?? [];
+            for (const v of values) {
+                const index = updatedOld.findIndex(o => o.nodeId === v.nodeId && o.definedAt === v.definedAt);
+                if (index < 0) {
+                    updatedOld.push(v);
+                }
+            }
+            map.set(key, [...updatedOld]);
+        }
+        else {
+            map.set(key, values);
+        }
+    }
+    let parent;
+    if (includeParent) {
+        parent = base.parent === undefined ? undefined : overwriteIEnvironmentWith(base.parent, next.parent);
+    }
+    else {
+        parent = base.parent;
+    }
+    const out = new environment_1.Environment(base.name, parent);
+    out.memory = map;
+    return out;
+}
+exports.overwriteIEnvironmentWith = overwriteIEnvironmentWith;
+/**
+ * Assumes, that all definitions within next replace those within base (given the same name).
+ * <b>But</b> if all definitions within next are maybe, then they are appended to the base definitions (updating them to be `maybe` from now on as well), similar to {@link appendEnvironments}.
+ */
+function overwriteEnvironments(base, next) {
+    if (base === undefined) {
+        return next;
+    }
+    else if (next === undefined) {
+        return base;
+    }
+    (0, assert_1.guard)(next.level === base.level, `cannot overwrite environments with differently nested local scopes, base ${base.level} vs. next ${next.level}. This should not happen.`);
+    return {
+        current: overwriteIEnvironmentWith(base.current, next.current),
+        level: base.level
+    };
+}
+exports.overwriteEnvironments = overwriteEnvironments;
+//# sourceMappingURL=overwrite.js.map

package/dataflow/environments/register.d.ts

@@ -0,0 +1,7 @@
+import { IdentifierDefinition, REnvironmentInformation } from './environment';
+import { DataflowScopeName } from './scopes';
+/**
+ * Insert the given `definition` --- defined within the given scope --- into the passed along `environments` will take care of propagation.
+ * Does not modify the passed along `environments` in-place! It returns the new reference.
+ */
+export declare function define(definition: IdentifierDefinition, withinScope: DataflowScopeName, environments: REnvironmentInformation): REnvironmentInformation;

package/dataflow/environments/register.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.define = void 0;
+const environment_1 = require("./environment");
+const scopes_1 = require("./scopes");
+const assert_1 = require("../../util/assert");
+/**
+ * Insert the given `definition` --- defined within the given scope --- into the passed along `environments` will take care of propagation.
+ * Does not modify the passed along `environments` in-place! It returns the new reference.
+ */
+function define(definition, withinScope, environments) {
+    let newEnvironments = environments;
+    if (withinScope === scopes_1.LocalScope) {
+        newEnvironments = (0, environment_1.cloneEnvironments)(environments, false);
+        newEnvironments.current.memory.set(definition.name, [definition]);
+    }
+    else if (withinScope === scopes_1.GlobalScope) {
+        newEnvironments = (0, environment_1.cloneEnvironments)(environments, true);
+        let current = newEnvironments.current;
+        let last = undefined;
+        let found = false;
+        do {
+            if (current.memory.has(definition.name)) {
+                current.memory.set(definition.name, [definition]);
+                found = true;
+                break;
+            }
+            last = current;
+            current = current.parent;
+        } while (current !== undefined);
+        if (!found) {
+            (0, assert_1.guard)(last !== undefined, () => `Could not find global scope for ${definition.name}`);
+            last.memory.set(definition.name, [definition]);
+        }
+    }
+    return newEnvironments;
+}
+exports.define = define;
+//# sourceMappingURL=register.js.map

package/dataflow/environments/resolve-by-name.d.ts

@@ -0,0 +1,12 @@
+import { Identifier, IdentifierDefinition, REnvironmentInformation } from './environment';
+import { DataflowScopeName } from './scopes';
+/**
+ * Resolves a given identifier name to a list of its possible definition location using R scoping and resolving rules.
+ *
+ * @param name - The name of the identifier to resolve
+ * @param withinScope - The scope in which the identifier is used
+ * @param environments - The current environments used for name resolution
+ *
+ * @returns A list of possible definitions of the identifier (one if the definition location is exactly and always known), or `undefined` if the identifier is undefined in the current scope/with the current environment information.
+ */
+export declare function resolveByName(name: Identifier, withinScope: DataflowScopeName, environments: REnvironmentInformation): IdentifierDefinition[] | undefined;

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveByName = void 0;
+const index_1 = require("../index");
+const scopes_1 = require("./scopes");
+/**
+ * Resolves a given identifier name to a list of its possible definition location using R scoping and resolving rules.
+ *
+ * @param name - The name of the identifier to resolve
+ * @param withinScope - The scope in which the identifier is used
+ * @param environments - The current environments used for name resolution
+ *
+ * @returns A list of possible definitions of the identifier (one if the definition location is exactly and always known), or `undefined` if the identifier is undefined in the current scope/with the current environment information.
+ */
+function resolveByName(name, withinScope, environments) {
+    if (withinScope !== scopes_1.LocalScope) {
+        throw new Error('Non-local scoping is not yet supported');
+    }
+    return resolve(name, withinScope, environments);
+}
+exports.resolveByName = resolveByName;
+function resolve(name, withinScope, environments) {
+    index_1.dataflowLogger.trace(`Resolving local identifier ${name} (scope name: ${withinScope}, local stack size: ${environments.level})`);
+    let current = environments.current;
+    do {
+        const definition = current.memory.get(name);
+        if (definition !== undefined) {
+            return definition;
+        }
+        current = current.parent;
+    } while (current !== undefined);
+    index_1.dataflowLogger.trace(`Unable to find identifier ${name} in stack`);
+    return undefined;
+}
+//# sourceMappingURL=resolve-by-name.js.map

package/dataflow/environments/scopes.d.ts

@@ -0,0 +1,6 @@
+export declare const GlobalScope = ".GlobalEnv";
+export declare const LocalScope = "local";
+/**
+ * Used to represent usual R scopes
+ */
+export type DataflowScopeName = /** default R global environment */ typeof GlobalScope | /** unspecified automatic local environment */ typeof LocalScope | /** named environments */ string;

package/dataflow/environments/scopes.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalScope = exports.GlobalScope = void 0;
+exports.GlobalScope = '.GlobalEnv';
+exports.LocalScope = 'local';
+//# sourceMappingURL=scopes.js.map

package/dataflow/environments/scoping.d.ts

@@ -0,0 +1,4 @@
+import { REnvironmentInformation } from './environment';
+/** Add a new local environment scope to the stack, returns the modified variant - sharing the original environments in the stack (no deep-clone) */
+export declare function pushLocalEnvironment(base: REnvironmentInformation): REnvironmentInformation;
+export declare function popLocalEnvironment(base: REnvironmentInformation): REnvironmentInformation;

package/dataflow/environments/scoping.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.popLocalEnvironment = exports.pushLocalEnvironment = void 0;
+const environment_1 = require("./environment");
+const assert_1 = require("../../util/assert");
+const scopes_1 = require("./scopes");
+/** Add a new local environment scope to the stack, returns the modified variant - sharing the original environments in the stack (no deep-clone) */
+function pushLocalEnvironment(base) {
+    const local = new environment_1.Environment(scopes_1.LocalScope);
+    local.parent = base.current;
+    return {
+        current: local,
+        level: base.level + 1
+    };
+}
+exports.pushLocalEnvironment = pushLocalEnvironment;
+function popLocalEnvironment(base) {
+    (0, assert_1.guard)(base.level > 0, 'cannot remove the global/root environment');
+    const parent = base.current.parent;
+    (0, assert_1.guard)(parent !== undefined, 'level is wrong, parent is undefined even though level suggested depth > 0 (starts with 0)');
+    return {
+        current: parent,
+        level: base.level - 1
+    };
+}
+exports.popLocalEnvironment = popLocalEnvironment;
+//# sourceMappingURL=scoping.js.map

package/dataflow/extractor.d.ts

@@ -0,0 +1,6 @@
+import { NormalizedAst, ParentInformation, RBinaryOp } from '../r-bridge';
+import { DataflowInformation } from './internal/info';
+import { DataflowProcessorInformation } from './processor';
+import { DataflowScopeName } from './environments';
+export declare function produceDataFlowGraph<OtherInfo>(ast: NormalizedAst<OtherInfo & ParentInformation>, initialScope?: DataflowScopeName): DataflowInformation;
+export declare function processBinaryOp<OtherInfo>(node: RBinaryOp<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/extractor.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processBinaryOp = exports.produceDataFlowGraph = void 0;
+const processor_1 = require("./processor");
+const uninteresting_leaf_1 = require("./internal/process/uninteresting-leaf");
+const symbol_1 = require("./internal/process/symbol");
+const non_assignment_binary_op_1 = require("./internal/process/operators/non-assignment-binary-op");
+const unary_op_1 = require("./internal/process/operators/unary-op");
+const expression_list_1 = require("./internal/process/expression-list");
+const repeat_loop_1 = require("./internal/process/loops/repeat-loop");
+const for_loop_1 = require("./internal/process/loops/for-loop");
+const while_loop_1 = require("./internal/process/loops/while-loop");
+const if_then_else_1 = require("./internal/process/if-then-else");
+const function_call_1 = require("./internal/process/functions/function-call");
+const function_definition_1 = require("./internal/process/functions/function-definition");
+const parameter_1 = require("./internal/process/functions/parameter");
+const environments_1 = require("./environments");
+const argument_1 = require("./internal/process/functions/argument");
+const assignment_1 = require("./internal/process/operators/assignment");
+const access_1 = require("./internal/process/access");
+const pipe_1 = require("./internal/process/operators/pipe");
+const scopes_1 = require("./environments/scopes");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- allows type adaption without re-creation
+const processors = {
+    ["RNumber" /* RType.Number */]: uninteresting_leaf_1.processUninterestingLeaf,
+    ["RString" /* RType.String */]: uninteresting_leaf_1.processUninterestingLeaf,
+    ["RLogical" /* RType.Logical */]: uninteresting_leaf_1.processUninterestingLeaf,
+    ["RAccess" /* RType.Access */]: access_1.processAccess,
+    ["RSymbol" /* RType.Symbol */]: symbol_1.processSymbol,
+    ["RBinaryOp" /* RType.BinaryOp */]: processBinaryOp,
+    ["RPipe" /* RType.Pipe */]: pipe_1.processPipeOperation,
+    ["RUnaryOp" /* RType.UnaryOp */]: unary_op_1.processUnaryOp,
+    ["RForLoop" /* RType.ForLoop */]: for_loop_1.processForLoop,
+    ["RWhileLoop" /* RType.WhileLoop */]: while_loop_1.processWhileLoop,
+    ["RRepeatLoop" /* RType.RepeatLoop */]: repeat_loop_1.processRepeatLoop,
+    ["RIfThenElse" /* RType.IfThenElse */]: if_then_else_1.processIfThenElse,
+    ["RBreak" /* RType.Break */]: uninteresting_leaf_1.processUninterestingLeaf,
+    ["RNext" /* RType.Next */]: uninteresting_leaf_1.processUninterestingLeaf,
+    ["RComment" /* RType.Comment */]: uninteresting_leaf_1.processUninterestingLeaf,
+    ["RLineDirective" /* RType.LineDirective */]: uninteresting_leaf_1.processUninterestingLeaf,
+    ["RFunctionCall" /* RType.FunctionCall */]: function_call_1.processFunctionCall,
+    ["RFunctionDefinition" /* RType.FunctionDefinition */]: function_definition_1.processFunctionDefinition,
+    ["RParameter" /* RType.Parameter */]: parameter_1.processFunctionParameter,
+    ["RArgument" /* RType.Argument */]: argument_1.processFunctionArgument,
+    ["RExpressionList" /* RType.ExpressionList */]: expression_list_1.processExpressionList,
+};
+function produceDataFlowGraph(ast, initialScope = scopes_1.LocalScope) {
+    return (0, processor_1.processDataflowFor)(ast.ast, { completeAst: ast, activeScope: initialScope, environments: (0, environments_1.initializeCleanEnvironments)(), processors: processors });
+}
+exports.produceDataFlowGraph = produceDataFlowGraph;
+function processBinaryOp(node, data) {
+    if (node.flavor === 'assignment') {
+        return (0, assignment_1.processAssignment)(node, data);
+    }
+    else {
+        return (0, non_assignment_binary_op_1.processNonAssignmentBinaryOp)(node, data);
+    }
+}
+exports.processBinaryOp = processBinaryOp;
+//# sourceMappingURL=extractor.js.map

package/dataflow/graph/diff.d.ts

@@ -0,0 +1,18 @@
+import { NodeId } from '../../r-bridge';
+import { DataflowGraph, FunctionArgument, OutgoingEdges } from './graph';
+import { GenericDifferenceInformation, DifferenceReport } from '../../util/diff';
+export interface NamedGraph {
+    name: string;
+    graph: DataflowGraph;
+}
+interface DataflowDiffContext extends GenericDifferenceInformation {
+    left: DataflowGraph;
+    right: DataflowGraph;
+}
+export declare function diffOfDataflowGraphs(left: NamedGraph, right: NamedGraph): DifferenceReport;
+export declare function equalExitPoints(a: NodeId[] | undefined, b: NodeId[] | undefined): boolean;
+export declare function equalFunctionArguments(a: false | FunctionArgument[], b: false | FunctionArgument[]): boolean;
+export declare function diffFunctionArguments(a: false | FunctionArgument[], b: false | FunctionArgument[], ctx: GenericDifferenceInformation): void;
+export declare function diffVertices(ctx: DataflowDiffContext): void;
+export declare function diffEdges(ctx: DataflowDiffContext, id: NodeId, lEdges: OutgoingEdges | undefined, rEdges: OutgoingEdges | undefined): void;
+export {};