@eagleoutice/flowr 2.8.15 → 2.9.1

package/dataflow/environments/identifier.js

@@ -1,7 +1,165 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReferenceTypeReverseMapping = exports.ReferenceType = void 0;
+exports.ReferenceTypeReverseMapping = exports.ReferenceType = exports.Identifier = void 0;
 exports.isReferenceType = isReferenceType;
+const strings_1 = require("../../util/text/strings");
+const dotDotDotAccess = /^\.\.\d+$/;
+/**
+ * Helper functions to work with {@link Identifier|identifiers}.
+ * Use {@link Identifier.matches} to check if two identifiers match according to R's scoping rules!
+ * @example
+ * ```ts
+ * const id1 = Identifier.make('a', 'pkg');
+ * const id2 = Identifier.parse('pkg::a');
+ * const id3 = Identifier.parse('a');
+ * Identifier.matches(id1, id2); // true
+ * Identifier.matches(id3, id2); // true, as id3 has no namespace
+ * ```
+ */
+exports.Identifier = {
+    /**
+     * Create an identifier from its name and optional namespace.
+     * Please note that for `internal` to count, a namespace must be provided!
+     */
+    make(name, namespace, internal = false) {
+        if ((0, strings_1.startAndEndsWith)(name, '`')) {
+            name = name.substring(1, name.length - 1);
+        }
+        if (namespace) {
+            return [name, namespace, internal];
+        }
+        else {
+            return name;
+        }
+    },
+    /**
+     * Parse an identifier from its string representation,
+     * Please note, that in R if one writes `"pkg::a"` this refers to a symbol named `pkg::a` and NOT to the namespaced identifier `a` in package `pkg`.
+     * In this scenario, see {@link Identifier.make} instead.
+     */
+    parse(str) {
+        const internal = str.includes(':::');
+        const parts = str.split(internal ? ':::' : '::');
+        if (parts.length === 2) {
+            return [parts[1], parts[0], internal];
+        }
+        return parts[0];
+    },
+    /**
+     * Get the name part of the identifier
+     */
+    getName(id) {
+        return Array.isArray(id) ? id[0] : id;
+    },
+    /**
+     * Get the namespace part of the identifier, undefined if there is none
+     */
+    getNamespace(id) {
+        return Array.isArray(id) ? id[1] : undefined;
+    },
+    /**
+     * Check if the identifier accesses internal objects (`:::`)
+     */
+    accessesInternal(id) {
+        return Array.isArray(id) ? id[2] : undefined;
+    },
+    /**
+     * Convert the identifier to a **valid R** string representation,
+     * this will properly quote namespaces that contain `::` to avoid confusion.
+     * @example
+     * ```ts
+     * Identifier.toString('a') // 'a'
+     * Identifier.toString(['a', 'pkg']) // 'pkg::a'
+     * Identifier.toString(['a', 'pkg:::internal', true]) // '"pkg:::internal":::a'
+     * ```
+     */
+    toString(id) {
+        if (Array.isArray(id)) {
+            if (id[1].includes('::')) {
+                return `${JSON.stringify(id[1])}${id[2] ? ':::' : '::'}${id[0]}`;
+            }
+            return `${id[1]}${id[2] ? ':::' : '::'}${id[0]}`;
+        }
+        else {
+            if (id.includes('::')) {
+                return JSON.stringify(id);
+            }
+            return id;
+        }
+    },
+    /**
+     * Check if two identifiers match.
+     * This differs from eq!
+     * If the first identifier is not namespaced, it will match any namespace!
+     * If we search for S3 methods (s3=true), the target may have an additional suffix after a dot.
+     * If the first identifier is internal, it will match any target (internal or not).
+     */
+    matches(id, target, s3 = false) {
+        const idName = exports.Identifier.getName(id);
+        const targetName = exports.Identifier.getName(target);
+        if (idName !== targetName) {
+            return s3 ? targetName.startsWith(idName + '.') : false;
+        }
+        const idNs = exports.Identifier.getNamespace(id);
+        if (idNs === undefined) {
+            return true;
+        }
+        const targetNs = exports.Identifier.getNamespace(target);
+        if (idNs !== targetNs) {
+            return false;
+        }
+        const idInternal = exports.Identifier.accessesInternal(id);
+        if (idInternal === true) {
+            return true;
+        }
+        const targetInternal = exports.Identifier.accessesInternal(target);
+        return idInternal === targetInternal;
+    },
+    /** Special identifier for the `...` argument */
+    dotdotdot() {
+        return '...';
+    },
+    /**
+     * Check if the identifier is the special `...` argument / or one of its accesses like `..1`, `..2`, etc.
+     * This always returns false for namespaced identifiers.
+     */
+    isDotDotDotAccess(id) {
+        return !Array.isArray(id) && (dotDotDotAccess.test(id) || id === '...');
+    },
+    /**
+     * Functor over the name of the identifier
+     */
+    mapName(id, fn) {
+        if (Array.isArray(id)) {
+            return [fn(id[0]), id[1], id[2]];
+        }
+        else {
+            return fn(id);
+        }
+    },
+    /**
+     * Functor over the namespace of the identifier
+     */
+    mapNamespace(id, fn) {
+        if (Array.isArray(id)) {
+            return [id[0], fn(id[1]), id[2]];
+        }
+        else {
+            return id;
+        }
+    },
+    /**
+     * Convert the identifier to its array representation
+     */
+    toArray(id) {
+        if (Array.isArray(id)) {
+            return [id[0], id[1], id[2]];
+        }
+        else {
+            return [id, undefined, undefined];
+        }
+    }
+};
 /**
  * Each reference has exactly one reference type, stored as the respective number.
  * However, when checking, we may want to allow for one of several types,
@@ -34,6 +192,8 @@ var ReferenceType;
     ReferenceType[ReferenceType["BuiltInFunction"] = 128] = "BuiltInFunction";
     /** Prefix to identify S3 methods, use this, to for example dispatch a call to `f` which will then link to `f.*` */
     ReferenceType[ReferenceType["S3MethodPrefix"] = 256] = "S3MethodPrefix";
+    /** Prefix to identify S7 methods, use this, to for example dispatch a call to `f` which will then link to `f<7>*` */
+    ReferenceType[ReferenceType["S7MethodPrefix"] = 512] = "S7MethodPrefix";
 })(ReferenceType || (exports.ReferenceType = ReferenceType = {}));
 /** Reverse mapping of the reference types so you can get the name from the bitmask (useful for debugging) */
 exports.ReferenceTypeReverseMapping = new Map(Object.entries(ReferenceType).map(([k, v]) => [v, k]));

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

@@ -1,20 +1,20 @@
 import type { REnvironmentInformation } from './environment';
 import { Ternary } from '../../util/logic';
-import { type Identifier, type IdentifierDefinition, ReferenceType } from './identifier';
+import { Identifier, type IdentifierDefinition, ReferenceType } from './identifier';
 /**
  * Resolves a given identifier name to a list of its possible definition location using R scoping and resolving rules.
  * If the type you want to reference is unknown, please use {@link resolveByNameAnyType} instead.
- * @param name               - The name of the identifier to resolve
+ * @param id                 - The identifier to resolve (optionally namespaced)
  * @param environment        - The current environment used for name resolution
  * @param target             - The target (meta) type of the identifier to resolve
  * @returns A list of possible identifier definitions (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, environment: REnvironmentInformation, target: ReferenceType): readonly IdentifierDefinition[] | undefined;
+export declare function resolveByName(id: Identifier, environment: REnvironmentInformation, target: ReferenceType): readonly IdentifierDefinition[] | undefined;
 /**
  * The more performant version of {@link resolveByName} when the target type is unknown.
  */
-export declare function resolveByNameAnyType(name: Identifier, environment: REnvironmentInformation): IdentifierDefinition[] | undefined;
+export declare function resolveByNameAnyType(id: Identifier, environment: REnvironmentInformation): IdentifierDefinition[] | undefined;
 /**
  * Checks whether the given identifier name resolves to a built-in constant with the given value.
  * @param name               - The name of the identifier to resolve

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

@@ -6,6 +6,7 @@ exports.resolvesToBuiltInConstant = resolvesToBuiltInConstant;
 const logic_1 = require("../../util/logic");
 const identifier_1 = require("./identifier");
 const info_1 = require("../info");
+const built_in_s_seven_dispatch_1 = require("../internal/process/functions/call/built-in/built-in-s-seven-dispatch");
 const FunctionTargetTypes = identifier_1.ReferenceType.Function | identifier_1.ReferenceType.BuiltInFunction | identifier_1.ReferenceType.Unknown | identifier_1.ReferenceType.Argument | identifier_1.ReferenceType.Parameter;
 const VariableTargetTypes = identifier_1.ReferenceType.Variable | identifier_1.ReferenceType.Parameter | identifier_1.ReferenceType.Argument | identifier_1.ReferenceType.Unknown;
 const ConstantTargetTypes = identifier_1.ReferenceType.Constant | identifier_1.ReferenceType.BuiltInConstant | identifier_1.ReferenceType.Unknown;
@@ -21,34 +22,44 @@ const TargetTypePredicate = {
     [identifier_1.ReferenceType.BuiltInConstant]: ({ type }) => (0, identifier_1.isReferenceType)(type, BuiltInConstantTargetTypes),
     [identifier_1.ReferenceType.BuiltInFunction]: ({ type }) => (0, identifier_1.isReferenceType)(type, BuiltInFunctionTargetTypes),
     [identifier_1.ReferenceType.S3MethodPrefix]: ({ type }) => (0, identifier_1.isReferenceType)(type, FunctionTargetTypes),
+    [identifier_1.ReferenceType.S7MethodPrefix]: ({ type }) => (0, identifier_1.isReferenceType)(type, FunctionTargetTypes),
 };
 /**
  * Resolves a given identifier name to a list of its possible definition location using R scoping and resolving rules.
  * If the type you want to reference is unknown, please use {@link resolveByNameAnyType} instead.
- * @param name               - The name of the identifier to resolve
+ * @param id                 - The identifier to resolve (optionally namespaced)
  * @param environment        - The current environment used for name resolution
  * @param target             - The target (meta) type of the identifier to resolve
  * @returns A list of possible identifier definitions (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, environment, target) {
+function resolveByName(id, environment, target) {
     if (target === identifier_1.ReferenceType.Unknown) {
-        return resolveByNameAnyType(name, environment);
+        return resolveByNameAnyType(id, environment);
     }
+    const [name, ns, internal] = identifier_1.Identifier.toArray(id);
     let current = environment.current;
     let definitions = undefined;
     const wantedType = TargetTypePredicate[target];
     do {
+        if (ns && current.n !== ns) {
+            current = current.parent;
+            continue;
+        }
         let definition;
-        if (target === identifier_1.ReferenceType.S3MethodPrefix) {
-            // S3 method prefixes only resolve to functions
+        if (target === identifier_1.ReferenceType.S3MethodPrefix || target === identifier_1.ReferenceType.S7MethodPrefix) {
+            // S3 method prefixes only resolve to functions, S3s must not match the exported criteria!
+            const infix = target === identifier_1.ReferenceType.S3MethodPrefix ? '.' : built_in_s_seven_dispatch_1.S7DispatchSeparator;
             definition = current.memory.entries()
-                .filter(([defName]) => defName.startsWith(name + '.'))
+                .filter(([defName]) => defName.startsWith(name + infix))
                 .flatMap(([, defs]) => defs)
                 .toArray();
         }
         else {
             definition = current.memory.get(name);
+            if (internal === false) {
+                definition = definition?.filter(({ name }) => name === undefined || !identifier_1.Identifier.accessesInternal(name));
+            }
         }
         if (definition !== undefined && definition.length > 0) {
             const filtered = definition.filter(wantedType);
@@ -77,16 +88,24 @@ function resolveByName(name, environment, target) {
 /**
  * The more performant version of {@link resolveByName} when the target type is unknown.
  */
-function resolveByNameAnyType(name, environment) {
+function resolveByNameAnyType(id, environment) {
     let current = environment.current;
-    const g = current.cache?.get(name);
+    const g = current.cache?.get(id);
     if (g !== undefined) {
         return g;
     }
+    const [name, ns, internal] = identifier_1.Identifier.toArray(id);
     let definitions = undefined;
     do {
-        const definition = current.memory.get(name);
+        if (ns && current.n !== ns) {
+            current = current.parent;
+            continue;
+        }
+        let definition = current.memory.get(name);
         if (definition) {
+            if (internal === false) {
+                definition = definition.filter(({ name }) => name === undefined || !identifier_1.Identifier.accessesInternal(name));
+            }
             if (definition.every(d => (0, info_1.happensInEveryBranch)(d.cds))) {
                 environment.current.cache ??= new Map();
                 environment.current.cache?.set(name, definition);
@@ -113,7 +132,7 @@ function resolveByNameAnyType(name, environment) {
     }
     if (ret) {
         environment.current.cache ??= new Map();
-        environment.current.cache?.set(name, ret);
+        environment.current.cache?.set(id, ret);
     }
     return ret;
 }

package/dataflow/eval/resolve/alias-tracking.js

@@ -87,6 +87,10 @@ function getAliases(sourceIds, dataflow, environment) {
         if (info === undefined) {
             return undefined;
         }
+        else if (info.tag === vertex_1.VertexType.FunctionDefinition) {
+            definitions.add(sourceId);
+            continue;
+        }
         const defs = AliasHandler[info.tag](sourceId, dataflow, environment);
         for (const def of defs ?? []) {
             definitions.add(def);
@@ -351,7 +355,10 @@ function resolveToConstants(name, environment) {
         return r_value_1.Top;
     }
     const values = new Set();
-    definitions.forEach(def => values.add((0, general_1.valueFromTsValue)(def.value ?? r_value_1.Top)));
+    definitions.forEach(def => {
+        const d = def.value;
+        values.add(d === undefined ? r_value_1.Top : (0, general_1.valueFromTsValue)(d));
+    });
     return (0, set_constants_1.setFrom)(...values);
 }
 //# sourceMappingURL=alias-tracking.js.map

package/dataflow/eval/resolve/resolve.d.ts

@@ -12,6 +12,7 @@ import type { ReadOnlyFlowrAnalyzerContext } from '../../../project/context/flow
  * aliases and vectors (in case of a vector).
  * @param a       - Ast node to resolve
  * @param resolve - Variable resolve mode
+ * @param ctx     - Analyzer context
  * @param env     - Environment to use
  * @param graph   - Dataflow Graph to use
  * @param map     - Idmap of Dataflow Graph
@@ -41,9 +42,10 @@ export declare function resolveAsVector(resolve: VariableResolve, node: RNodeWit
  * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
  * @param resolve  - Variable resolve mode
  * @param operator - Node of the sequence operator to resolve
- * @param env      - Environment to use
  * @param graph    - Dataflow graph
- * @param map      - Id map of the dataflow graph
+ * @param ctx      - Analyzer context
+ * @param idMap    - Id map of the dataflow graph
+ * @param environment - Environment to use
  * @returns ValueVector of ValueNumbers or Top
  */
 export declare function resolveAsSeq(resolve: VariableResolve, operator: RNodeWithParent, ctx: ReadOnlyFlowrAnalyzerContext, environment?: REnvironmentInformation, graph?: DataflowGraph, idMap?: AstIdMap): ValueVector<Lift<ValueNumber[]>> | typeof Top;
@@ -55,9 +57,10 @@ export declare function resolveAsSeq(resolve: VariableResolve, operator: RNodeWi
  * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
  * @param resolve  - Variable resolve mode
  * @param operator - Node of the plus operator to resolve
- * @param env      - Environment to use
  * @param graph    - Dataflow graph
- * @param map      - Id map of the dataflow graph
+ * @param ctx      - Analyzer context
+ * @param idMap    - Id map of the dataflow graph
+ * @param environment - Environment to use
  * @returns ValueNumber, ValueVector of ValueNumbers, or Top
  */
 export declare function resolveAsPlus(resolve: VariableResolve, operator: RNodeWithParent, ctx: ReadOnlyFlowrAnalyzerContext, environment?: REnvironmentInformation, graph?: DataflowGraph, idMap?: AstIdMap): ValueNumber | ValueVector<Lift<ValueNumber[]>> | typeof Top;
@@ -69,9 +72,10 @@ export declare function resolveAsPlus(resolve: VariableResolve, operator: RNodeW
  * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
  * @param resolve  - Variable resolve mode
  * @param operator - Node of the minus operator to resolve
- * @param env      - Environment to use
  * @param graph    - Dataflow graph
- * @param map      - Id map of the dataflow graph
+ * @param ctx      - Analyzer context
+ * @param idMap    - Id map of the dataflow graph
+ * @param environment - Environment to use
  * @returns ValueNumber, ValueVector of ValueNumbers, or Top
  */
 export declare function resolveAsMinus(resolve: VariableResolve, operator: RNodeWithParent, ctx: ReadOnlyFlowrAnalyzerContext, environment?: REnvironmentInformation, graph?: DataflowGraph, idMap?: AstIdMap): ValueNumber | ValueVector<Lift<ValueNumber[]>> | typeof Top;

package/dataflow/eval/resolve/resolve.js

@@ -17,6 +17,7 @@ const string_constants_1 = require("../values/string/string-constants");
 const vector_constants_1 = require("../values/vectors/vector-constants");
 const alias_tracking_1 = require("./alias-tracking");
 const scalar_constants_1 = require("../values/scalar/scalar-constants");
+const identifier_1 = require("../../environments/identifier");
 /**
  * Helper function used by {@link resolveIdToValue}, please use that instead, if
  * you want to resolve the value of an identifier / node
@@ -25,6 +26,7 @@ const scalar_constants_1 = require("../values/scalar/scalar-constants");
  * aliases and vectors (in case of a vector).
  * @param a       - Ast node to resolve
  * @param resolve - Variable resolve mode
+ * @param ctx     - Analyzer context
  * @param env     - Environment to use
  * @param graph   - Dataflow Graph to use
  * @param map     - Idmap of Dataflow Graph
@@ -53,7 +55,7 @@ function resolveNode(resolve, a, ctx, env, graph, map) {
             builtInName = origin.proc;
         }
         else if (a.type === type_1.RType.FunctionCall && a.named) {
-            builtInName = (0, built_in_1.builtInId)(a.functionName.content);
+            builtInName = (0, built_in_1.builtInId)(identifier_1.Identifier.getName(a.functionName.content));
         }
         else if (a.type === type_1.RType.BinaryOp || a.type === type_1.RType.UnaryOp) {
             builtInName = (0, built_in_1.builtInId)(a.operator);
@@ -98,9 +100,10 @@ function resolveAsVector(resolve, node, ctx, environment, graph, idMap) {
  * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
  * @param resolve  - Variable resolve mode
  * @param operator - Node of the sequence operator to resolve
- * @param env      - Environment to use
  * @param graph    - Dataflow graph
- * @param map      - Id map of the dataflow graph
+ * @param ctx      - Analyzer context
+ * @param idMap    - Id map of the dataflow graph
+ * @param environment - Environment to use
  * @returns ValueVector of ValueNumbers or Top
  */
 function resolveAsSeq(resolve, operator, ctx, environment, graph, idMap) {
@@ -125,9 +128,10 @@ function resolveAsSeq(resolve, operator, ctx, environment, graph, idMap) {
  * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
  * @param resolve  - Variable resolve mode
  * @param operator - Node of the plus operator to resolve
- * @param env      - Environment to use
  * @param graph    - Dataflow graph
- * @param map      - Id map of the dataflow graph
+ * @param ctx      - Analyzer context
+ * @param idMap    - Id map of the dataflow graph
+ * @param environment - Environment to use
  * @returns ValueNumber, ValueVector of ValueNumbers, or Top
  */
 function resolveAsPlus(resolve, operator, ctx, environment, graph, idMap) {
@@ -153,9 +157,10 @@ function resolveAsPlus(resolve, operator, ctx, environment, graph, idMap) {
  * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
  * @param resolve  - Variable resolve mode
  * @param operator - Node of the minus operator to resolve
- * @param env      - Environment to use
  * @param graph    - Dataflow graph
- * @param map      - Id map of the dataflow graph
+ * @param ctx      - Analyzer context
+ * @param idMap    - Id map of the dataflow graph
+ * @param environment - Environment to use
  * @returns ValueNumber, ValueVector of ValueNumbers, or Top
  */
 function resolveAsMinus(resolve, operator, ctx, environment, graph, idMap) {

package/dataflow/eval/values/general.js

@@ -39,7 +39,7 @@ function valueFromTsValue(a) {
         return r_value_1.Bottom;
     }
     else if (a === null) {
-        return r_value_1.Top;
+        return { type: 'null' };
     }
     else if (typeof a === 'string') {
         return (0, string_constants_1.stringFrom)(a);

package/dataflow/eval/values/r-value.d.ts

@@ -37,6 +37,9 @@ export interface ValueString<Str extends Lift<RStringValue> = Lift<RStringValue>
     type: 'string';
     value: Str;
 }
+export interface ValueNull {
+    type: 'null';
+}
 export interface ValueFunctionDefinition {
     type: 'function-definition';
 }
@@ -48,7 +51,7 @@ export interface ValueLogical {
     type: 'logical';
     value: Lift<TernaryLogical>;
 }
-export type Value = Lift<ValueInterval | ValueVector | ValueSet | ValueNumber | ValueString | ValueLogical | ValueMissing | ValueFunctionDefinition>;
+export type Value = Lift<ValueInterval | ValueVector | ValueSet | ValueNumber | ValueString | ValueLogical | ValueMissing | ValueFunctionDefinition | ValueNull>;
 export type ValueType<V> = V extends {
     type: infer T;
 } ? T : never;

package/dataflow/eval/values/r-value.js

@@ -76,6 +76,8 @@ function stringifyValue(value) {
     return tryStringifyBoTop(value, v => {
         const t = v.type;
         switch (t) {
+            case 'null':
+                return 'NULL';
             case 'interval':
                 return `${v.startInclusive ? '[' : '('}${stringifyValue(v.start)}, ${stringifyValue(v.end)}${v.endInclusive ? ']' : ')'}`;
             case 'vector':

package/dataflow/extractor.js

@@ -20,6 +20,7 @@ const edge_1 = require("./graph/edge");
 const identify_link_to_last_call_relation_1 = require("../queries/catalog/call-context-query/identify-link-to-last-call-relation");
 const built_in_function_definition_1 = require("./internal/process/functions/call/built-in/built-in-function-definition");
 const flowr_file_1 = require("../project/context/flowr-file");
+const identifier_1 = require("./environments/identifier");
 /**
  * The best friend of {@link produceDataFlowGraph} and {@link processDataflowFor}.
  * Maps every {@link RType} in the normalized AST to a processor.
@@ -53,7 +54,7 @@ exports.processors = {
             content: groupStart?.content ?? '{',
             lexeme: groupStart?.lexeme ?? '{',
             location: location ?? (0, range_1.invalidRange)(),
-            namespace: groupStart?.content ? undefined : 'base'
+            ns: groupStart?.content ? undefined : 'base'
         }, (0, make_argument_1.wrapArgumentsUnnamed)(children, d.completeAst.idMap), info.id, d);
     }
 };
@@ -71,7 +72,7 @@ function resolveLinkToSideEffects(ast, graph) {
             cf = (0, extract_cfg_1.extractCfgQuick)(ast);
             if (graph.unknownSideEffects.size > 20) {
                 knownCalls = (0, extract_cfg_1.getCallsInCfg)(cf, graph);
-                allCallNames = Array.from(new Set(knownCalls.values().map(c => c.name)));
+                allCallNames = Array.from(new Set(knownCalls.values().map(c => identifier_1.Identifier.toString(c.name))));
             }
         }
         else if (handled.has(s.id)) {
@@ -109,10 +110,12 @@ function produceDataFlowGraph(parser, completeAst, ctx) {
     // we freeze the files here to avoid endless modifications during processing
     const files = completeAst.ast.files.slice();
     ctx.files.addConsideredFile(files[0].filePath ? files[0].filePath : flowr_file_1.FlowrFile.INLINE_PATH);
+    const env = ctx.env.makeCleanEnv();
+    env.current.n = ctx.meta.getNamespace();
     const dfData = {
         parser,
         completeAst,
-        environment: ctx.env.makeCleanEnv(),
+        environment: env,
         processors: ctx.config.solver.instrument.dataflowExtractors?.(exports.processors, ctx) ?? exports.processors,
         cds: undefined,
         referenceChain: [files[0].filePath],

package/dataflow/fn/higher-order-function.js

@@ -21,8 +21,8 @@ function isAnyReturnAFunction(def, graph) {
             return true;
         }
         const next = graph.outgoingEdges(current.id) ?? [];
-        for (const [t, { types }] of next) {
-            if ((0, edge_1.edgeIncludesType)(types, edge_1.EdgeType.Returns)) {
+        for (const [t, e] of next) {
+            if (edge_1.DfEdge.includesType(e, edge_1.EdgeType.Returns)) {
                 const v = graph.getVertex(t);
                 if (v) {
                     workingQueue.push(v);
@@ -34,8 +34,8 @@ function isAnyReturnAFunction(def, graph) {
 }
 function inspectCallSitesArgumentsFns(def, graph, ctx) {
     const callSites = graph.ingoingEdges(def.id);
-    for (const [callerId, { types }] of callSites ?? []) {
-        if (!(0, edge_1.edgeIncludesType)(types, edge_1.EdgeType.Calls)) {
+    for (const [callerId, e] of callSites ?? []) {
+        if (!edge_1.DfEdge.includesType(e, edge_1.EdgeType.Calls)) {
             continue;
         }
         const caller = graph.getVertex(callerId);

package/dataflow/graph/call-graph.d.ts

@@ -14,7 +14,7 @@ export type CallGraph = DataflowGraph<Required<DataflowGraphVertexFunctionCall |
  */
 export declare function getSubCallGraph(graph: CallGraph, entryPoints: Set<NodeId>): CallGraph;
 /**
- *
+ * Determines whether there is a path from `from` to `to` in the given graph (via any edge type, only respecting direction)
  */
 export declare function reaches(from: NodeId, to: NodeId, graph: DataflowGraph, knownReachability?: DefaultMap<NodeId, Set<NodeId>>): boolean;
 /**

package/dataflow/graph/call-graph.js

@@ -28,8 +28,8 @@ function getSubCallGraph(graph, entryPoints) {
             continue;
         }
         result.addVertex(currentVtx, undefined, true);
-        for (const [tar, { types }] of graph.outgoingEdges(currentId) ?? []) {
-            if ((0, edge_1.edgeIncludesType)(types, edge_1.EdgeType.Calls)) {
+        for (const [tar, e] of graph.outgoingEdges(currentId) ?? []) {
+            if (edge_1.DfEdge.includesType(e, edge_1.EdgeType.Calls)) {
                 result.addEdge(currentId, tar, edge_1.EdgeType.Calls);
                 toVisit.push(tar);
             }
@@ -38,7 +38,7 @@ function getSubCallGraph(graph, entryPoints) {
     return result;
 }
 /**
- *
+ * Determines whether there is a path from `from` to `to` in the given graph (via any edge type, only respecting direction)
  */
 function reaches(from, to, graph, knownReachability = new defaultmap_1.DefaultMap(() => new Set())) {
     const visited = new Set();
@@ -147,8 +147,8 @@ function fallbackUntargetedCall(vtx, graph) {
             continue;
         }
         let addedNew = false;
-        for (const [tar, { types }] of graph.outgoingEdges(currentId) ?? []) {
-            if ((0, edge_1.edgeIncludesType)(types, UntargetedCallFollow) && (0, edge_1.edgeDoesNotIncludeType)(types, UntargetedCallAvoid)) {
+        for (const [tar, e] of graph.outgoingEdges(currentId) ?? []) {
+            if (edge_1.DfEdge.includesType(e, UntargetedCallFollow) && edge_1.DfEdge.doesNotIncludeType(e, UntargetedCallAvoid)) {
                 addedNew = true;
                 toVisit.push(tar);
             }
@@ -174,10 +174,12 @@ function processCall(vtx, from, graph, result, state) {
     // for each call, resolve the targets
     const tars = (0, linker_1.getAllFunctionCallTargets)(vid, graph, vtx.environment);
     let addedTarget = false;
+    let addedBiTarget = false;
     for (const tar of tars) {
         if ((0, built_in_1.isBuiltIn)(tar)) {
             result.addEdge(vid, tar, edge_1.EdgeType.Calls);
             addedTarget = true;
+            addedBiTarget = true;
             continue;
         }
         const targetVtx = graph.getVertex(tar);
@@ -187,7 +189,7 @@ function processCall(vtx, from, graph, result, state) {
         addedTarget = true;
         processFunctionDefinition(targetVtx, vid, graph, result, state);
     }
-    if (vtx.origin !== 'unnamed') {
+    if (!addedBiTarget && vtx.origin !== 'unnamed') {
         for (const origs of vtx.origin) {
             if (origs.startsWith('builtin:')) {
                 addedTarget = true;
@@ -217,8 +219,8 @@ function processCall(vtx, from, graph, result, state) {
         }
     }
     // handle arguments, traversing the 'reads' and the 'returns' edges
-    for (const [tar, { types }] of graph.outgoingEdges(vtx.id) ?? []) {
-        if ((0, edge_1.edgeDoesNotIncludeType)(types, edge_1.EdgeType.Reads | edge_1.EdgeType.Returns | edge_1.EdgeType.Argument)) {
+    for (const [tar, e] of graph.outgoingEdges(vtx.id) ?? []) {
+        if (edge_1.DfEdge.doesNotIncludeType(e, edge_1.EdgeType.Reads | edge_1.EdgeType.Returns | edge_1.EdgeType.Argument)) {
             continue;
         }
         const tVtx = graph.getVertex(tar);

package/dataflow/graph/diff-dataflow-graph.js

@@ -12,6 +12,7 @@ const arrays_1 = require("../../util/collections/arrays");
 const vertex_1 = require("./vertex");
 const edge_1 = require("./edge");
 const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
+const identifier_1 = require("../environments/identifier");
 const diff_2 = require("../environments/diff");
 const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const info_1 = require("../info");
@@ -293,9 +294,10 @@ function diffReferenceLists(fn, a, b, ctx) {
     const aSorted = [...a].sort((x, y) => x.nodeId.toString().localeCompare(y.nodeId.toString()));
     const bSorted = [...b].sort((x, y) => x.nodeId.toString().localeCompare(y.nodeId.toString()));
     for (let i = 0; i < aSorted.length; ++i) {
+        const inam = aSorted[i].name;
         (0, diff_2.diffIdentifierReferences)(aSorted[i], bSorted[i], {
             ...ctx,
-            position: `${ctx.position}In reference #${i} ("${aSorted[i].name ?? '?'}", id: ${aSorted[i].nodeId ?? '?'}) `,
+            position: `${ctx.position}In reference #${i} ("${inam ? identifier_1.Identifier.toString(inam) : '?'}", id: ${aSorted[i].nodeId ?? '?'}) `,
         });
     }
 }
@@ -325,13 +327,13 @@ function diffHooks(left, right, ctx, id) {
     }
 }
 function diffEdge(edge, otherEdge, ctx, id, target) {
-    const edgeTypes = (0, edge_1.splitEdgeTypes)(edge.types);
-    const otherEdgeTypes = (0, edge_1.splitEdgeTypes)(otherEdge.types);
+    const edgeTypes = edge_1.DfEdge.splitTypes(edge);
+    const otherEdgeTypes = edge_1.DfEdge.splitTypes(otherEdge);
     if ((edgeTypes.length < otherEdgeTypes.length && !ctx.config.leftIsSubgraph) || (edgeTypes.length > otherEdgeTypes.length && !ctx.config.rightIsSubgraph)) {
         ctx.report.addComment(`Target of ${id}->${target} in ${ctx.leftname} differs in number of edge types: ${JSON.stringify([...edgeTypes])} vs ${JSON.stringify([...otherEdgeTypes])}`, { tag: 'edge', from: id, to: target });
     }
     if (edge.types !== otherEdge.types) {
-        ctx.report.addComment(`Target of ${id}->${target} in ${ctx.leftname} differs in edge types: ${JSON.stringify([...(0, edge_1.edgeTypesToNames)(edge.types)])} vs ${JSON.stringify([...(0, edge_1.edgeTypesToNames)(otherEdge.types)])}`, { tag: 'edge', from: id, to: target });
+        ctx.report.addComment(`Target of ${id}->${target} in ${ctx.leftname} differs in edge types: ${JSON.stringify([...edge_1.DfEdge.typesToNames(edge)])} vs ${JSON.stringify([...edge_1.DfEdge.typesToNames(otherEdge)])}`, { tag: 'edge', from: id, to: target });
     }
 }
 /**