@eagleoutice/flowr 1.3.11

package/dataflow/common/environments/environment.js

@@ -0,0 +1,165 @@
+"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 makeReferenceMaybe(ref, graph, environments) {
+    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' };
+}
+function makeAllMaybe(references, graph, environments) {
+    if (references === undefined) {
+        return [];
+    }
+    return references.map(ref => makeReferenceMaybe(ref, graph, environments));
+}
+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;
+        }
+        // we sort both value arrays by their id so that we have no problems with differently ordered arrays (which have no impact)
+        const sorted = [...value].sort((a, b) => a.nodeId.localeCompare(b.nodeId));
+        const sorted2 = [...value2].sort((a, b) => a.nodeId.localeCompare(b.nodeId));
+        for (let i = 0; i < value.length; ++i) {
+            const aVal = sorted[i];
+            const bVal = sorted2[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} (${aVal.nodeId}). ${info.leftname}: ${aVal.scope} vs. ${info.rightname}: ${bVal.scope}`);
+            }
+            if (aVal.used !== bVal.used) {
+                info.report.addComment(`${info.position}Different used for ${key} (${aVal.nodeId}). ${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} (${aVal.nodeId}). ${info.leftname}: ${aVal.definedAt} vs. ${info.rightname}: ${bVal.definedAt}`);
+            }
+            if (aVal.kind !== bVal.kind) {
+                info.report.addComment(`${info.position}Different kinds for ${key} (${aVal.nodeId}). ${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/common/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/common/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/common/environments/register.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.define = void 0;
+const assert_1 = require("../../../util/assert");
+const environment_1 = require("./environment");
+const scopes_1 = require("./scopes");
+function defInEnv(newEnvironments, definition) {
+    const existing = newEnvironments.memory.get(definition.name);
+    // check if it is maybe or not
+    if (existing === undefined || definition.used === 'always') {
+        newEnvironments.memory.set(definition.name, [definition]);
+    }
+    else {
+        existing.push(definition);
+    }
+}
+/**
+ * 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);
+        defInEnv(newEnvironments.current, 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/common/environments/resolve-by-name.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveByName = void 0;
+const v1_1 = require("../../v1");
+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) {
+    v1_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);
+    v1_1.dataflowLogger.trace(`Unable to find identifier ${name} in stack`);
+    return undefined;
+}
+//# sourceMappingURL=resolve-by-name.js.map

package/dataflow/common/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/common/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/environments/append.d.ts

@@ -0,0 +1,8 @@
+import { REnvironmentInformation } from './environment';
+/**
+ * Adds all writes of `next` to `base` (i.e., the operations of `next` *might* happen).
+ */
+export declare function appendEnvironments(base: REnvironmentInformation, next: REnvironmentInformation | undefined): REnvironmentInformation;
+export declare function appendEnvironments(base: REnvironmentInformation | undefined, next: REnvironmentInformation): REnvironmentInformation;
+export declare function appendEnvironments(base: undefined, next: undefined): undefined;
+export declare function appendEnvironments(base: REnvironmentInformation | undefined, next: REnvironmentInformation | undefined): REnvironmentInformation | undefined;

package/dataflow/environments/append.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendEnvironments = void 0;
+const assert_1 = require("../../util/assert");
+const environment_1 = require("./environment");
+function uniqueMergeValues(old, value) {
+    const result = old;
+    for (const v of value) {
+        const find = result.findIndex(o => o.nodeId === v.nodeId && o.definedAt === v.definedAt);
+        if (find < 0) {
+            result.push(v);
+        }
+    }
+    return result;
+}
+function appendIEnvironmentWith(base, next) {
+    (0, assert_1.guard)(base !== undefined && next !== undefined, 'can not append 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, value] of next.memory) {
+        const old = map.get(key);
+        if (old) {
+            map.set(key, uniqueMergeValues(old, value));
+        }
+        else {
+            map.set(key, value);
+        }
+    }
+    const parent = base.parent === undefined ? undefined : appendIEnvironmentWith(base.parent, next.parent);
+    const out = new environment_1.Environment(base.name, parent);
+    out.memory = map;
+    return out;
+}
+function appendEnvironments(base, next) {
+    if (base === undefined) {
+        return next;
+    }
+    else if (next === undefined) {
+        return base;
+    }
+    (0, assert_1.guard)(base.level === next.level, 'environments must have the same level to be handled, it is up to the caller to ensure that');
+    return {
+        current: appendIEnvironmentWith(base.current, next.current),
+        level: base.level,
+    };
+}
+exports.appendEnvironments = appendEnvironments;
+//# sourceMappingURL=append.js.map

package/dataflow/environments/environment.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Provides an environment structure similar to R.
+ * This allows the dataflow to hold current definition locations for variables, based on the current scope.
+ *
+ * @module
+ */
+import { NodeId } from '../../r-bridge';
+import { DataflowGraph, DataflowGraphEdgeAttribute } from '../graph';
+import { DataflowScopeName } from './scopes';
+import { GenericDifferenceInformation } from '../../util/diff';
+/** identifiers are branded to avoid confusion with other string-like types */
+export type Identifier = string & {
+    __brand?: 'identifier';
+};
+export declare const BuiltIn = "built-in";
+/**
+ * Stores the definition of an identifier within an {@link IEnvironment}
+ */
+export interface IdentifierDefinition extends IdentifierReference {
+    kind: 'function' | 'variable' | 'parameter' | 'unknown' | 'built-in-function' | 'argument';
+    /** The assignment (or whatever, like `assign` function call) node which ultimately defined this identifier */
+    definedAt: NodeId;
+}
+/**
+ * Something like `a` in `b <- a`.
+ * Without any surrounding information, `a` will produce the
+ * identifier reference `a` in the current scope (like the global environment).
+ * Similarly, `b` will create a reference.
+ */
+export interface IdentifierReference {
+    name: Identifier;
+    scope: DataflowScopeName;
+    /** Node which represents the reference in the AST */
+    nodeId: NodeId;
+    /**
+   * Is this reference used in every execution path of the program or only if some of them. This can be too-conservative regarding `maybe`.
+   * For example, if we can not detect `if(FALSE)`, this will be `maybe` even if we could statically determine, that the `then` branch is never executed.
+   */
+    used: DataflowGraphEdgeAttribute;
+}
+export declare function diffIdentifierReferences(a: IdentifierReference, b: IdentifierReference, info: GenericDifferenceInformation): void;
+export declare function makeAllMaybe(references: IdentifierReference[] | undefined, graph: DataflowGraph, environments: REnvironmentInformation): IdentifierReference[];
+export interface IEnvironment {
+    /** unique and internally generated identifier -- will not be used for comparison but assists debugging for tracking identities */
+    readonly id: string;
+    readonly name: string;
+    /** Lexical parent of the environment, if any (can be manipulated by R code) */
+    parent?: IEnvironment;
+    /**
+   * Maps to exactly one definition of an identifier if the source is known, otherwise to a list of all possible definitions
+   */
+    memory: Map<Identifier, IdentifierDefinition[]>;
+}
+export declare class Environment implements IEnvironment {
+    readonly name: string;
+    readonly id: string;
+    parent?: IEnvironment;
+    memory: Map<Identifier, IdentifierDefinition[]>;
+    constructor(name: string, parent?: IEnvironment);
+}
+/**
+ * First of all, yes, R stores its environments differently, potentially even with a different differentiation between
+ * the `baseenv`, the `emptyenv`and other default environments. Yet, during dataflow we want sometimes to know more (static
+ * reference information) and sometimes know less (to be honest we do not want that,
+ * but statically determining all attached environments is theoretically impossible --- consider attachments by user input).
+ * One example would be maps holding a potential list of all definitions of a variable, if we do not know the execution path (like with `if(x) A else B`).
+ */
+export interface REnvironmentInformation {
+    /**  The currently active environment (the stack is represented by the currently active {@link IEnvironment#parent}). Environments are maintained within the dataflow graph. */
+    readonly current: IEnvironment;
+    /** nesting level of the environment, will be `0` for the global/root environment */
+    readonly level: number;
+}
+export declare const DefaultEnvironmentMemory: Map<Identifier, IdentifierDefinition[]>;
+export declare function initializeCleanEnvironments(): REnvironmentInformation;
+export declare function diffEnvironment(a: IEnvironment | undefined, b: IEnvironment | undefined, info: GenericDifferenceInformation): void;
+export declare function diffEnvironments(a: REnvironmentInformation | undefined, b: REnvironmentInformation | undefined, info: GenericDifferenceInformation): void;
+export declare function cloneEnvironments(environment: REnvironmentInformation, recurseParents?: boolean): REnvironmentInformation;