@eagleoutice/flowr 1.5.2 → 2.0.0

package/dataflow/environments/environment.js

@@ -1,43 +1,39 @@
 "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;
+exports.initializeCleanEnvironments = exports.GLOBAL_ENV_NAME = exports.BuiltInEnvironment = exports.Environment = exports.makeAllMaybe = exports.makeReferenceMaybe = void 0;
+const built_in_1 = require("./built-in");
 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}`);
+function makeReferenceMaybe(ref, graph, environments, includeDefs, defaultCd = undefined) {
+    const node = graph.get(ref.nodeId, true);
+    if (includeDefs) {
+        const definitions = ref.name ? (0, resolve_by_name_1.resolveByName)(ref.name, environments) : undefined;
+        for (const definition of definitions ?? []) {
+            if (definition.kind !== 'built-in-function' && definition.kind !== 'built-in-value') {
+                if (definition.controlDependencies && defaultCd && !definition.controlDependencies.includes(defaultCd)) {
+                    definition.controlDependencies.push(defaultCd);
+                }
+                else {
+                    definition.controlDependencies = defaultCd ? [defaultCd] : [];
+                }
+            }
+        }
     }
-    if (a.used !== b.used) {
-        info.report.addComment(`${info.position}Different used: ${a.used} vs. ${b.used}`);
+    if (node) {
+        if (node[0].controlDependencies && defaultCd && !node[0].controlDependencies.includes(defaultCd)) {
+            node[0].controlDependencies.push(defaultCd);
+        }
+        else {
+            node[0].controlDependencies = defaultCd ? [defaultCd] : [];
+        }
     }
+    return { ...ref, controlDependencies: [...ref.controlDependencies ?? [], ...(defaultCd ? [defaultCd] : [])] };
 }
-exports.diffIdentifierReferences = diffIdentifierReferences;
-function makeAllMaybe(references, graph, environments) {
+exports.makeReferenceMaybe = makeReferenceMaybe;
+function makeAllMaybe(references, graph, environments, includeDefs, defaultCd = undefined) {
     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' };
-    });
+    return references.map(ref => makeReferenceMaybe(ref, graph, environments, includeDefs, defaultCd));
 }
 exports.makeAllMaybe = makeAllMaybe;
 let environmentIdCounter = 0;
@@ -53,117 +49,15 @@ class Environment {
     }
 }
 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
-            }]],
-    ['source', [{
-                kind: 'built-in-function',
-                scope: scopes_1.GlobalScope,
-                used: 'always',
-                definedAt: exports.BuiltIn,
-                name: 'source',
-                nodeId: exports.BuiltIn
-            }]]
-]);
+/* the built-in environment is the root of all environments */
+exports.BuiltInEnvironment = new Environment('built-in', undefined);
+exports.BuiltInEnvironment.memory = built_in_1.BuiltInMemory;
+exports.GLOBAL_ENV_NAME = 'global';
 function initializeCleanEnvironments() {
-    const global = new Environment(scopes_1.GlobalScope);
-    // use a copy
-    global.memory = new Map(exports.DefaultEnvironmentMemory);
     return {
-        current: global,
+        current: new Environment(exports.GLOBAL_ENV_NAME, exports.BuiltInEnvironment),
         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/identifier.d.ts

@@ -0,0 +1,31 @@
+import type { BuiltInIdentifierConstant, BuiltInIdentifierDefinition } from './built-in';
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+export type Identifier = string & {
+    __brand?: 'identifier';
+};
+interface InGraphIdentifierDefinition extends IdentifierReference {
+    kind: 'function' | 'variable' | 'parameter' | 'argument';
+    /** The assignment (or whatever, like `assign` function call) node which ultimately defined this identifier */
+    definedAt: NodeId;
+}
+/**
+ * Stores the definition of an identifier within an {@link IEnvironment}
+ */
+export type IdentifierDefinition = InGraphIdentifierDefinition | BuiltInIdentifierDefinition | BuiltInIdentifierConstant;
+/**
+ * Something like `a` in `b <- a`.
+ * Without any surrounding information, `a` will produce the identifier reference `a`.
+ * Similarly, `b` will create a reference.
+ */
+export interface IdentifierReference {
+    /** Node which represents the reference in the AST */
+    readonly nodeId: NodeId;
+    /** Name the reference is identified by (e.g., the name of the variable), undefined if the reference is "artificial" (e.g., anonymous) */
+    readonly name: Identifier | undefined;
+    /**
+     * If the reference is only effective if, e.g. an if-then-else condition is true, this references the root of the `if`.
+     * As a hackey intermediate solution (until we have pointer-analysis), an empty array may indicate a `maybe` which is due to pointer access (e.g., in `a[x] <- 3`).
+     */
+    controlDependencies: NodeId[] | undefined;
+}
+export {};

package/dataflow/environments/identifier.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=identifier.js.map

package/dataflow/environments/overwrite.d.ts

@@ -1,6 +1,6 @@
 import type { 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;
+export declare function overwriteEnvironment(base: REnvironmentInformation, next: REnvironmentInformation | undefined): REnvironmentInformation;
+export declare function overwriteEnvironment(base: REnvironmentInformation | undefined, next: REnvironmentInformation): REnvironmentInformation;
+export declare function overwriteEnvironment(base: undefined, next: undefined): undefined;
+export declare function overwriteEnvironment(base: REnvironmentInformation | undefined, next: REnvironmentInformation | undefined): REnvironmentInformation | undefined;

package/dataflow/environments/overwrite.js

@@ -1,29 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.overwriteEnvironments = exports.overwriteIEnvironmentWith = void 0;
+exports.overwriteEnvironment = exports.overwriteIEnvironmentWith = void 0;
 const assert_1 = require("../../util/assert");
 const environment_1 = require("./environment");
-function anyIsMaybeGuardingSame(values) {
+function anyIsMaybeOrEmpty(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') {
+    for (const val of values) {
+        if (val.controlDependencies !== undefined) {
             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;
 }
@@ -32,7 +19,7 @@ function overwriteIEnvironmentWith(base, next, includeParent = true) {
     (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);
+        const hasMaybe = anyIsMaybeOrEmpty(values);
         if (hasMaybe) {
             const old = map.get(key);
             // we need to make a copy to avoid side effects for old reference in other environments
@@ -51,7 +38,7 @@ function overwriteIEnvironmentWith(base, next, includeParent = true) {
     }
     let parent;
     if (includeParent) {
-        parent = base.parent === undefined ? undefined : overwriteIEnvironmentWith(base.parent, next.parent);
+        parent = base.parent.id === environment_1.BuiltInEnvironment.id ? environment_1.BuiltInEnvironment : overwriteIEnvironmentWith(base.parent, next.parent);
     }
     else {
         parent = base.parent;
@@ -63,9 +50,9 @@ function overwriteIEnvironmentWith(base, next, includeParent = true) {
 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}.
+ * <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 appendEnvironment}.
  */
-function overwriteEnvironments(base, next) {
+function overwriteEnvironment(base, next) {
     if (base === undefined) {
         return next;
     }
@@ -78,5 +65,5 @@ function overwriteEnvironments(base, next) {
         level: base.level
     };
 }
-exports.overwriteEnvironments = overwriteEnvironments;
+exports.overwriteEnvironment = overwriteEnvironment;
 //# sourceMappingURL=overwrite.js.map

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

@@ -1,12 +1,13 @@
-import type { Identifier, IdentifierDefinition, REnvironmentInformation } from './environment';
-import type { DataflowScopeName } from './scopes';
+import type { REnvironmentInformation } from './environment';
+import type { Ternary } from '../../util/logic';
+import type { Identifier, IdentifierDefinition } from './identifier';
 /**
  * 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
+ * @param name         - The name of the identifier to resolve
+ * @param environment  - The current environment 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;
+export declare function resolveByName(name: Identifier, environment: REnvironmentInformation): IdentifierDefinition[] | undefined;
+export declare function resolvesToBuiltInConstant(name: Identifier | undefined, environment: REnvironmentInformation, wantedValue: unknown): Ternary;

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

@@ -1,35 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveByName = void 0;
-const index_1 = require("../index");
-const scopes_1 = require("./scopes");
+exports.resolvesToBuiltInConstant = exports.resolveByName = void 0;
+const environment_1 = require("./environment");
 /**
  * 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
+ * @param name         - The name of the identifier to resolve
+ * @param environment  - The current environment 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;
+function resolveByName(name, environment) {
+    let current = environment.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;
+    } while (current.id !== environment_1.BuiltInEnvironment.id);
+    return current.memory.get(name);
+}
+exports.resolveByName = resolveByName;
+function resolvesToBuiltInConstant(name, environment, wantedValue) {
+    if (name === undefined) {
+        return 'never';
+    }
+    const definition = resolveByName(name, environment);
+    if (definition === undefined) {
+        return 'never';
+    }
+    let all = true;
+    let some = false;
+    for (const def of definition) {
+        if (def.kind === 'built-in-value' && def.value === wantedValue) {
+            some = true;
+        }
+        else {
+            all = false;
+        }
+    }
+    if (all) {
+        return 'always';
+    }
+    else {
+        return some ? 'maybe' : 'never';
+    }
 }
+exports.resolvesToBuiltInConstant = resolvesToBuiltInConstant;
 //# sourceMappingURL=resolve-by-name.js.map

package/dataflow/environments/scoping.js

@@ -3,13 +3,10 @@ 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,
+        current: new environment_1.Environment('local', base.current),
         level: base.level + 1
     };
 }

package/dataflow/extractor.d.ts

@@ -1,6 +1,6 @@
-import type { NormalizedAst, ParentInformation, RBinaryOp, RParseRequest } from '../r-bridge';
-import type { DataflowInformation } from './internal/info';
-import type { DataflowProcessorInformation } from './processor';
-import type { DataflowScopeName } from './environments';
-export declare function produceDataFlowGraph<OtherInfo>(request: RParseRequest, ast: NormalizedAst<OtherInfo & ParentInformation>, initialScope?: DataflowScopeName): DataflowInformation;
-export declare function processBinaryOp<OtherInfo>(node: RBinaryOp<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;
+import type { DataflowInformation } from './info';
+import type { DataflowProcessors } from './processor';
+import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { RParseRequest } from '../r-bridge/retriever';
+export declare const processors: DataflowProcessors<ParentInformation>;
+export declare function produceDataFlowGraph<OtherInfo>(request: RParseRequest, ast: NormalizedAst<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/extractor.js

@@ -1,68 +1,58 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processBinaryOp = exports.produceDataFlowGraph = void 0;
-const r_bridge_1 = require("../r-bridge");
+exports.produceDataFlowGraph = exports.processors = 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,
+const process_uninteresting_leaf_1 = require("./internal/process/process-uninteresting-leaf");
+const process_symbol_1 = require("./internal/process/process-symbol");
+const default_call_handling_1 = require("./internal/process/functions/call/default-call-handling");
+const process_parameter_1 = require("./internal/process/functions/process-parameter");
+const process_argument_1 = require("./internal/process/functions/process-argument");
+const process_named_call_1 = require("./internal/process/process-named-call");
+const process_value_1 = require("./internal/process/process-value");
+const named_call_handling_1 = require("./internal/process/functions/call/named-call-handling");
+const make_argument_1 = require("./internal/process/functions/call/argument/make-argument");
+const range_1 = require("../util/range");
+const retriever_1 = require("../r-bridge/retriever");
+const environment_1 = require("./environments/environment");
+exports.processors = {
+    ["RNumber" /* RType.Number */]: process_value_1.processValue,
+    ["RString" /* RType.String */]: process_value_1.processValue,
+    ["RLogical" /* RType.Logical */]: process_value_1.processValue,
+    ["RComment" /* RType.Comment */]: process_uninteresting_leaf_1.processUninterestingLeaf,
+    ["RLineDirective" /* RType.LineDirective */]: process_uninteresting_leaf_1.processUninterestingLeaf,
+    ["RSymbol" /* RType.Symbol */]: process_symbol_1.processSymbol,
+    ["RAccess" /* RType.Access */]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.operator, [n.accessed, ...n.access]),
+    ["RBinaryOp" /* RType.BinaryOp */]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.operator, [n.lhs, n.rhs]),
+    ["RPipe" /* RType.Pipe */]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.lexeme, [n.lhs, n.rhs]),
+    ["RUnaryOp" /* RType.UnaryOp */]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.operator, [n.operand]),
+    ["RForLoop" /* RType.ForLoop */]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.lexeme, [n.variable, n.vector, n.body]),
+    ["RWhileLoop" /* RType.WhileLoop */]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.lexeme, [n.condition, n.body]),
+    ["RRepeatLoop" /* RType.RepeatLoop */]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.lexeme, [n.body]),
+    ["RIfThenElse" /* RType.IfThenElse */]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.lexeme, [n.condition, n.then, n.otherwise]),
+    ["RBreak" /* RType.Break */]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.lexeme, []),
+    ["RNext" /* RType.Next */]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.lexeme, []),
+    ["RFunctionCall" /* RType.FunctionCall */]: default_call_handling_1.processFunctionCall,
+    ["RFunctionDefinition" /* RType.FunctionDefinition */]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.lexeme, [...n.parameters, n.body]),
+    ["RParameter" /* RType.Parameter */]: process_parameter_1.processFunctionParameter,
+    ["RArgument" /* RType.Argument */]: process_argument_1.processFunctionArgument,
+    ["RExpressionList" /* RType.ExpressionList */]: (n, d) => (0, named_call_handling_1.processNamedCall)({
+        type: "RSymbol" /* RType.Symbol */,
+        info: n.info,
+        content: n.grouping?.[0].content ?? '{',
+        lexeme: n.grouping?.[0].lexeme ?? '{',
+        location: n.location ?? (0, range_1.rangeFrom)(-1, -1, -1, -1),
+        namespace: n.grouping?.[0].content ? undefined : 'base'
+    }, (0, make_argument_1.wrapArgumentsUnnamed)(n.children, d.completeAst.idMap), n.info.id, d)
 };
-function produceDataFlowGraph(request, ast, initialScope = scopes_1.LocalScope) {
+function produceDataFlowGraph(request, ast) {
     return (0, processor_1.processDataflowFor)(ast.ast, {
         completeAst: ast,
-        activeScope: initialScope,
-        environments: (0, environments_1.initializeCleanEnvironments)(),
-        processors: processors,
+        environment: (0, environment_1.initializeCleanEnvironments)(),
+        processors: exports.processors,
         currentRequest: request,
-        referenceChain: [(0, r_bridge_1.requestFingerprint)(request)]
+        controlDependencies: undefined,
+        referenceChain: [(0, retriever_1.requestFingerprint)(request)]
     });
 }
 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

@@ -1,18 +1,35 @@
-import type { NodeId } from '../../r-bridge';
 import type { DataflowGraph, FunctionArgument, OutgoingEdges } from './graph';
-import type { GenericDifferenceInformation, DifferenceReport } from '../../util/diff';
+import type { GenericDifferenceInformation, WriteableDifferenceReport } from '../../util/diff';
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+interface ProblematicVertex {
+    tag: 'vertex';
+    id: NodeId;
+}
+interface ProblematicEdge {
+    tag: 'edge';
+    from: NodeId;
+    to: NodeId;
+}
+export type ProblematicDiffInfo = ProblematicVertex | ProblematicEdge;
+export declare class DataflowDifferenceReport implements WriteableDifferenceReport {
+    _comments: string[] | undefined;
+    _problematic: ProblematicDiffInfo[] | undefined;
+    addComment(comment: string, ...related: ProblematicDiffInfo[]): void;
+    comments(): readonly string[] | undefined;
+    problematic(): readonly ProblematicDiffInfo[] | undefined;
+    isEqual(): boolean;
+}
 export interface NamedGraph {
     name: string;
     graph: DataflowGraph;
 }
-interface DataflowDiffContext extends GenericDifferenceInformation {
+interface DataflowDiffContext extends GenericDifferenceInformation<DataflowDifferenceReport> {
     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 diffOfDataflowGraphs(left: NamedGraph, right: NamedGraph): DataflowDifferenceReport;
+export declare function equalFunctionArguments(fn: NodeId, a: false | readonly FunctionArgument[], b: false | readonly FunctionArgument[]): boolean;
+export declare function diffFunctionArguments(fn: NodeId, a: false | readonly FunctionArgument[], b: false | readonly FunctionArgument[], ctx: GenericDifferenceInformation<DataflowDifferenceReport>): void;
 export declare function diffVertices(ctx: DataflowDiffContext): void;
 export declare function diffEdges(ctx: DataflowDiffContext, id: NodeId, lEdges: OutgoingEdges | undefined, rEdges: OutgoingEdges | undefined): void;
 export {};