@eagleoutice/flowr 2.9.9 → 2.9.11

package/dataflow/environments/built-in.js

@@ -1,9 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BuiltIns = exports.BuiltInEvalHandlerMapper = exports.BuiltInProcessorMapper = exports.BuiltInProcName = void 0;
-exports.builtInId = builtInId;
-exports.isBuiltIn = isBuiltIn;
-exports.dropBuiltInPrefix = dropBuiltInPrefix;
 const known_call_handling_1 = require("../internal/process/functions/call/known-call-handling");
 const built_in_access_1 = require("../internal/process/functions/call/built-in/built-in-access");
 const built_in_if_then_else_1 = require("../internal/process/functions/call/built-in/built-in-if-then-else");
@@ -21,6 +18,8 @@ const built_in_function_definition_1 = require("../internal/process/functions/ca
 const built_in_expression_list_1 = require("../internal/process/functions/call/built-in/built-in-expression-list");
 const built_in_get_1 = require("../internal/process/functions/call/built-in/built-in-get");
 const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const r_symbol_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-symbol");
+const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
 const edge_1 = require("../graph/edge");
 const built_in_library_1 = require("../internal/process/functions/call/built-in/built-in-library");
 const built_in_source_1 = require("../internal/process/functions/call/built-in/built-in-source");
@@ -30,7 +29,6 @@ const built_in_vector_1 = require("../internal/process/functions/call/built-in/b
 const built_in_rm_1 = require("../internal/process/functions/call/built-in/built-in-rm");
 const built_in_eval_1 = require("../internal/process/functions/call/built-in/built-in-eval");
 const vertex_1 = require("../graph/vertex");
-const type_1 = require("../../r-bridge/lang-4.x/ast/model/type");
 const unknown_side_effect_1 = require("../graph/unknown-side-effect");
 const resolve_1 = require("../eval/resolve/resolve");
 const built_in_stop_if_not_1 = require("../internal/process/functions/call/built-in/built-in-stop-if-not");
@@ -41,30 +39,11 @@ const built_in_s_three_dispatch_1 = require("../internal/process/functions/call/
 const built_in_recall_1 = require("../internal/process/functions/call/built-in/built-in-recall");
 const built_in_s_seven_new_generic_1 = require("../internal/process/functions/call/built-in/built-in-s-seven-new-generic");
 const built_in_s_seven_dispatch_1 = require("../internal/process/functions/call/built-in/built-in-s-seven-dispatch");
-/**
- * Generate a built-in id for the given name
- */
-function builtInId(name) {
-    return `built-in:${name}`;
-}
-/**
- * Checks whether the given name is a built-in identifier
- */
-function isBuiltIn(name) {
-    return String(name).startsWith('built-in:');
-}
-const builtInPrefixLength = 'built-in:'.length;
-/**
- * Drops the `built-in:` prefix from the given built-in name
- */
-function dropBuiltInPrefix(name) {
-    return name.slice(builtInPrefixLength);
-}
-function defaultBuiltInProcessor(name, args, rootId, data, { returnsNthArgument, useAsProcessor, forceArgs, readAllArguments, cfg, hasUnknownSideEffects, treatAsFnCall }) {
-    const activeProcessor = useAsProcessor ?? BuiltInProcName.Default;
-    const { information: res, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs, origin: activeProcessor });
+const r_string_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-string");
+function defaultBuiltInProcessor(name, args, rootId, data, { returnsNthArgument, useAsProcessor = BuiltInProcName.Default, forceArgs, readAllArguments, cfg, hasUnknownSideEffects, treatAsFnCall }) {
+    const { information: res, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs, origin: useAsProcessor });
     if (returnsNthArgument !== undefined) {
-        const arg = returnsNthArgument === 'last' ? processedArguments[args.length - 1] : processedArguments[returnsNthArgument];
+        const arg = returnsNthArgument === 'last' ? processedArguments.at(-1) : processedArguments[returnsNthArgument];
         if (arg !== undefined) {
             res.graph.addEdge(rootId, arg.entryPoint, edge_1.EdgeType.Returns);
         }
@@ -91,11 +70,11 @@ function defaultBuiltInProcessor(name, args, rootId, data, { returnsNthArgument,
                 const rhs = arg.value;
                 let fnName;
                 let fnId;
-                if (rhs.type === type_1.RType.String) {
+                if (r_string_1.RString.is(rhs)) {
                     fnName = rhs.content.str;
                     fnId = rhs.info.id;
                 }
-                else if (rhs.type === type_1.RType.Symbol) {
+                else if (r_symbol_1.RSymbol.is(rhs)) {
                     fnName = rhs.content;
                     fnId = rhs.info.id;
                 }
@@ -110,7 +89,7 @@ function defaultBuiltInProcessor(name, args, rootId, data, { returnsNthArgument,
                     environment: data.environment,
                     onlyBuiltin: false,
                     cds: data.cds,
-                    origin: [activeProcessor]
+                    origin: [useAsProcessor]
                 });
             }
         }
@@ -120,6 +99,16 @@ function defaultBuiltInProcessor(name, args, rootId, data, { returnsNthArgument,
     }
     return res;
 }
+function defaultBuiltInProcessorReadallArgs(name, args, rootId, data, { useAsProcessor = BuiltInProcName.Default, forceArgs }) {
+    const { information, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs, origin: useAsProcessor });
+    const g = information.graph;
+    for (const arg of processedArguments) {
+        if (arg) {
+            g.addEdge(rootId, arg.entryPoint, edge_1.EdgeType.Reads);
+        }
+    }
+    return information;
+}
 /**
  * This contains all names of built-in function handlers and origins
  */
@@ -137,6 +126,8 @@ var BuiltInProcName;
     BuiltInProcName["Break"] = "builtin:break";
     /** the default built-in processor, see {@link defaultBuiltInProcessor} */
     BuiltInProcName["Default"] = "builtin:default";
+    /** Just a more performant variant of the default processor for built-ins that need to read all their arguments, see {@link defaultBuiltInProcessor}, this will still produce the origin `BuiltIn.Default` */
+    BuiltInProcName["DefaultReadAllArgs"] = "builtin:default-read-all-args";
     /** for `eval` calls, see {@link processEvalCall} */
     BuiltInProcName["Eval"] = "builtin:eval";
     /** for expression lists, see {@link processExpressionList} */
@@ -208,6 +199,7 @@ exports.BuiltInProcessorMapper = {
     [BuiltInProcName.Assignment]: built_in_assignment_1.processAssignment,
     [BuiltInProcName.AssignmentLike]: built_in_assignment_1.processAssignmentLike,
     [BuiltInProcName.Default]: defaultBuiltInProcessor,
+    [BuiltInProcName.DefaultReadAllArgs]: defaultBuiltInProcessorReadallArgs,
     [BuiltInProcName.Eval]: built_in_eval_1.processEvalCall,
     [BuiltInProcName.ExpressionList]: built_in_expression_list_1.processExpressionList,
     [BuiltInProcName.ForLoop]: built_in_for_loop_1.processForLoop,
@@ -247,7 +239,7 @@ class BuiltIns {
     registerBuiltInConstant({ names, value, assumePrimitive }) {
         for (const name of names) {
             const n = identifier_1.Identifier.getName(name);
-            const id = builtInId(n);
+            const id = node_id_1.NodeId.toBuiltIn(n);
             const d = [{
                     type: identifier_1.ReferenceType.BuiltInConstant,
                     definedAt: id,
@@ -268,7 +260,7 @@ class BuiltIns {
         (0, assert_1.guard)(mappedProcessor !== undefined, () => `Processor for ${processor} is undefined! Please pass a valid builtin name ${JSON.stringify(Object.keys(exports.BuiltInProcessorMapper))}!`);
         for (const name of names) {
             const n = identifier_1.Identifier.getName(name);
-            const id = builtInId(n);
+            const id = node_id_1.NodeId.toBuiltIn(n);
             const d = [{
                     type: identifier_1.ReferenceType.BuiltInFunction,
                     definedAt: id,
@@ -291,7 +283,7 @@ class BuiltIns {
         for (const assignment of names) {
             for (const suffix of suffixes) {
                 const effectiveName = `${identifier_1.Identifier.getName(assignment)}${suffix}`;
-                const id = builtInId(effectiveName);
+                const id = node_id_1.NodeId.toBuiltIn(effectiveName);
                 const d = [{
                         type: identifier_1.ReferenceType.BuiltInFunction,
                         definedAt: id,

package/dataflow/environments/default-builtin-config.d.ts

@@ -36,18 +36,14 @@ export declare const DefaultBuiltinConfig: [{
 }, {
     readonly type: "function";
     readonly names: ["~", "+", "-", "*", "/", "^", "!", "?", "**", "==", "!=", ">", "<", ">=", "<=", "%%", "%/%", "%*%", "%in%", ":", "rep", "seq", "seq_len", "seq_along", "seq.int", "gsub", "which", "class", "dimnames", "min", "max", "intersect", "subset", "match", "sqrt", "abs", "round", "floor", "ceiling", "signif", "trunc", "log", "log10", "log2", "sum", "mean", "unique", "paste", "paste0", "read.csv", "is.null", "numeric", "as.character", "as.integer", "as.logical", "as.numeric", "as.matrix", "rbind", "nrow", "ncol", "tryCatch", "expression", "factor", "missing", "as.data.frame", "data.frame", "na.omit", "rownames", "names", "order", "length", "any", "dim", "matrix", "cbind", "nchar", "pdf", "jpeg", "png", "windows", "postscript", "xfig", "bitmap", "pictex", "cairo_pdf", "svg", "bmp", "tiff", "X11", "quartz", "jitter"];
-    readonly processor: BuiltInProcName.Default;
-    readonly config: {
-        readonly readAllArguments: true;
-    };
+    readonly processor: BuiltInProcName.DefaultReadAllArgs;
+    readonly config: {};
     readonly assumePrimitive: true;
 }, {
     readonly type: "function";
     readonly names: ["t", "aperm"];
-    readonly processor: BuiltInProcName.Default;
-    readonly config: {
-        readonly readAllArguments: true;
-    };
+    readonly processor: BuiltInProcName.DefaultReadAllArgs;
+    readonly config: {};
     readonly assumePrimitive: false;
 }, {
     readonly type: "function";

package/dataflow/environments/default-builtin-config.js

@@ -112,8 +112,8 @@ exports.DefaultBuiltinConfig = [
             'pdf', 'jpeg', 'png', 'windows', 'postscript', 'xfig', 'bitmap', 'pictex', 'cairo_pdf', 'svg', 'bmp', 'tiff', 'X11', 'quartz',
             'jitter'
         ],
-        processor: built_in_1.BuiltInProcName.Default,
-        config: { readAllArguments: true },
+        processor: built_in_1.BuiltInProcName.DefaultReadAllArgs,
+        config: {},
         assumePrimitive: true
     },
     {
@@ -121,8 +121,8 @@ exports.DefaultBuiltinConfig = [
         names: [
             't', 'aperm' /* transpose function, permutation generation */
         ],
-        processor: built_in_1.BuiltInProcName.Default,
-        config: { readAllArguments: true },
+        processor: built_in_1.BuiltInProcName.DefaultReadAllArgs,
+        config: {},
         assumePrimitive: false
     },
     { type: 'function', names: ['rm'], processor: built_in_1.BuiltInProcName.Rm, config: {}, assumePrimitive: true },
@@ -371,6 +371,9 @@ function getDefaultProcessor(name) {
     }
     const fn = exports.DefaultBuiltinConfig.find(def => (def.names.includes(name) && def.type !== 'constant')
         || (def.type === 'replacement' && def.suffixes.flatMap(d => def.names.map(n => `${n}${d}`)).includes(name)));
-    return fn?.type === 'replacement' ? built_in_1.BuiltInProcName.Replacement : fn?.processor;
+    if (fn?.type === 'replacement') {
+        return built_in_1.BuiltInProcName.Replacement;
+    }
+    return fn?.processor === built_in_1.BuiltInProcName.DefaultReadAllArgs ? built_in_1.BuiltInProcName.Default : fn?.processor;
 }
 //# sourceMappingURL=default-builtin-config.js.map

package/dataflow/environments/reference-to-maybe.d.ts

@@ -11,3 +11,11 @@ export declare function makeReferenceMaybe(ref: IdentifierReference, graph: Data
  * @see {@link makeReferenceMaybe}
  */
 export declare function makeAllMaybe(references: readonly IdentifierReference[] | undefined, graph: DataflowGraph, environments: REnvironmentInformation, includeDefs: boolean, applyCds?: ControlDependency[] | undefined): IdentifierReference[];
+/**
+ * apply the given cds to all elements in the graph and also transform the given references similar to {@link makeAllMaybe}.
+ */
+export declare function applyCdsToAllInGraphButConstants(graph: DataflowGraph, references: readonly IdentifierReference[], cds: readonly ControlDependency[]): void;
+/**
+ * apply the given cds to all given references, but not to the graph. This is useful if we want to mark the references as maybe without marking all other nodes in the graph as maybe.
+ */
+export declare function applyCdToReferences(references: readonly IdentifierReference[], cds: readonly ControlDependency[]): void;

package/dataflow/environments/reference-to-maybe.js

@@ -2,16 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeReferenceMaybe = makeReferenceMaybe;
 exports.makeAllMaybe = makeAllMaybe;
+exports.applyCdsToAllInGraphButConstants = applyCdsToAllInGraphButConstants;
+exports.applyCdToReferences = applyCdToReferences;
 const identifier_1 = require("./identifier");
 const resolve_by_name_1 = require("./resolve-by-name");
+const vertex_1 = require("../graph/vertex");
 function appToCdsUnique(target, toAdd) {
     if (toAdd) {
-        target.push(...toAdd.filter(c => !target.find(tc => tc.id === c.id && tc.when === c.when)));
+        target.push(...toAdd.filter(c => !target.some(tc => tc.id === c.id && tc.when === c.when)));
     }
 }
 function concatCdsUnique(target, toAdd) {
     if (toAdd) {
-        return target.concat(toAdd.filter(c => !target.find(tc => tc.id === c.id && tc.when === c.when)));
+        return target.concat(toAdd.filter(c => !target.some(tc => tc.id === c.id && tc.when === c.when)));
     }
     else {
         return target;
@@ -58,6 +61,46 @@ function makeReferenceMaybe(ref, graph, environments, includeDefs, defaultCd = u
  * @see {@link makeReferenceMaybe}
  */
 function makeAllMaybe(references, graph, environments, includeDefs, applyCds = undefined) {
-    return references?.map(ref => makeReferenceMaybe(ref, graph, environments, includeDefs, applyCds)) ?? [];
+    if (references === undefined || references.length === 0) {
+        return [];
+    }
+    return references.map(ref => makeReferenceMaybe(ref, graph, environments, includeDefs, applyCds));
+}
+/**
+ * apply the given cds to all elements in the graph and also transform the given references similar to {@link makeAllMaybe}.
+ */
+function applyCdsToAllInGraphButConstants(graph, references, cds) {
+    for (const [, v] of graph.vertices(true)) {
+        if (v.tag === vertex_1.VertexType.Value) {
+            continue;
+        }
+        if (v.cds) {
+            appToCdsUnique(v.cds, cds);
+        }
+        else {
+            v.cds = Array.from(cds);
+        }
+    }
+    for (const ref of references) {
+        if (ref.cds) {
+            appToCdsUnique(ref.cds, cds);
+        }
+        else {
+            ref.cds = Array.from(cds);
+        }
+    }
+}
+/**
+ * apply the given cds to all given references, but not to the graph. This is useful if we want to mark the references as maybe without marking all other nodes in the graph as maybe.
+ */
+function applyCdToReferences(references, cds) {
+    for (const ref of references) {
+        if (ref.cds) {
+            appToCdsUnique(ref.cds, cds);
+        }
+        else {
+            ref.cds = Array.from(cds);
+        }
+    }
 }
 //# sourceMappingURL=reference-to-maybe.js.map

package/dataflow/eval/resolve/alias-tracking.d.ts

@@ -1,6 +1,6 @@
 import { VariableResolve } from '../../../config';
 import type { AstIdMap, RNodeWithParent } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import { type NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { type REnvironmentInformation } from '../../environments/environment';
 import { Identifier } from '../../environments/identifier';
 import type { DataflowGraph } from '../../graph/graph';
@@ -58,7 +58,7 @@ export declare function getAliases(sourceIds: readonly NodeId[], dataflow: Dataf
  * @param ctx                - Context used for clean environment
  * @param blocked            - If set, the ids that should not be considered during resolution (=>top)
  */
-export declare function resolveIdToValue(id: NodeId | RNodeWithParent | undefined, { environment, graph, idMap, full, resolve, ctx, blocked }: ResolveInfo): ResolveResult;
+export declare function resolveIdToValue(id: NodeId | RNodeWithParent | undefined, { environment, graph, idMap, full, ctx, resolve, blocked }: ResolveInfo): ResolveResult;
 /**
  * Please use {@link resolveIdToValue}
  *

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

@@ -20,6 +20,7 @@ const general_1 = require("../values/general");
 const r_value_1 = require("../values/r-value");
 const set_constants_1 = require("../values/sets/set-constants");
 const resolve_1 = require("./resolve");
+const model_1 = require("../../../r-bridge/lang-4.x/ast/model/model");
 const AliasHandler = {
     [vertex_1.VertexType.Value]: (sourceId) => [sourceId],
     [vertex_1.VertexType.Use]: getUseAlias,
@@ -119,8 +120,7 @@ function getAliases(sourceIds, dataflow, environment) {
  * @param ctx                - Context used for clean environment
  * @param blocked            - If set, the ids that should not be considered during resolution (=>top)
  */
-function resolveIdToValue(id, { environment, graph, idMap, full = true, resolve, ctx, blocked }) {
-    const variableResolve = resolve ?? ctx.config.solver.variables;
+function resolveIdToValue(id, { environment, graph, idMap, full = true, ctx, resolve = ctx.config.solver.variables, blocked }) {
     blocked ??= new Set();
     if (id === undefined) {
         return r_value_1.Top;
@@ -134,13 +134,13 @@ function resolveIdToValue(id, { environment, graph, idMap, full = true, resolve,
     switch (node.type) {
         case type_1.RType.Argument:
             if (node.value) {
-                return resolveIdToValue(node.value.info.id, { environment, graph, idMap, full, resolve: variableResolve, ctx, blocked });
+                return resolveIdToValue(node.value.info.id, { environment, graph, idMap, full, resolve, ctx, blocked });
             }
         // eslint-disable-next-line no-fallthrough
         case type_1.RType.Symbol:
             if (full) {
                 if (environment) {
-                    return trackAliasInEnvironments(identifier_1.Identifier.toString(node.content), environment, { idMap, resolve: variableResolve, ctx, graph, blocked });
+                    return trackAliasInEnvironments(identifier_1.Identifier.toString(node.content), environment, { idMap, resolve, ctx, graph, blocked });
                 }
                 else if (graph && resolve === config_1.VariableResolve.Alias) {
                     return trackAliasesInGraph(node.info.id, graph, ctx, idMap);
@@ -153,7 +153,7 @@ function resolveIdToValue(id, { environment, graph, idMap, full = true, resolve,
         case type_1.RType.BinaryOp:
         case type_1.RType.UnaryOp:
             return (0, set_constants_1.setFrom)((0, resolve_1.resolveNode)({
-                resolve: variableResolve, node, ctx, environment, graph, idMap, blocked
+                resolve, node, ctx, environment, graph, idMap, blocked
             }));
         case type_1.RType.String:
         case type_1.RType.Number:
@@ -293,7 +293,7 @@ function trackAliasesInGraph(id, graph, ctx, idMap) {
             if (target === undefined) {
                 continue;
             }
-            if (target.type === type_1.RType.WhileLoop || target.type === type_1.RType.RepeatLoop || target.type === type_1.RType.ForLoop) {
+            if (model_1.RLoopConstructs.is(target)) {
                 forceTop = true;
                 break;
             }

package/dataflow/eval/resolve/resolve.js

@@ -18,6 +18,7 @@ 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");
+const node_id_1 = require("../../../r-bridge/lang-4.x/ast/model/processing/node-id");
 /**
  * Helper function used by {@link resolveIdToValue}, please use that instead, if
  * you want to resolve the value of an identifier / node
@@ -27,32 +28,33 @@ const identifier_1 = require("../../environments/identifier");
  * @returns resolved value or top/bottom
  */
 function resolveNode({ resolve, node, ctx, blocked, environment, graph, idMap }) {
-    if (node.type === type_1.RType.String) {
+    const nt = node.type;
+    if (nt === type_1.RType.String) {
         return (0, string_constants_1.stringFrom)(node.content.str);
     }
-    else if (node.type === type_1.RType.Number) {
+    else if (nt === type_1.RType.Number) {
         return (0, interval_constants_1.intervalFrom)(node.content.num, node.content.num);
     }
-    else if (node.type === type_1.RType.Logical) {
+    else if (nt === type_1.RType.Logical) {
         return node.content.valueOf() ? logical_constants_1.ValueLogicalTrue : logical_constants_1.ValueLogicalFalse;
     }
-    else if (node.type === type_1.RType.FunctionDefinition) {
+    else if (nt === type_1.RType.FunctionDefinition) {
         return { type: 'function-definition' };
     }
-    else if ((node.type === type_1.RType.FunctionCall || node.type === type_1.RType.BinaryOp || node.type === type_1.RType.UnaryOp) && graph) {
+    else if ((nt === type_1.RType.FunctionCall || nt === type_1.RType.BinaryOp || nt === type_1.RType.UnaryOp) && graph) {
         const origin = (0, dfg_get_origin_1.getOriginInDfg)(graph, node.info.id)?.[0];
         if (origin === undefined || origin.type !== 3 /* OriginType.BuiltInFunctionOrigin */) {
             return r_value_2.Top;
         }
         let builtInName;
-        if ((0, built_in_1.isBuiltIn)(origin.proc)) {
+        if (node_id_1.NodeId.isBuiltIn(origin.proc)) {
             builtInName = origin.proc;
         }
-        else if (node.type === type_1.RType.FunctionCall && node.named) {
-            builtInName = (0, built_in_1.builtInId)(identifier_1.Identifier.getName(node.functionName.content));
+        else if (nt === type_1.RType.FunctionCall && node.named) {
+            builtInName = node_id_1.NodeId.toBuiltIn(identifier_1.Identifier.getName(node.functionName.content));
         }
-        else if (node.type === type_1.RType.BinaryOp || node.type === type_1.RType.UnaryOp) {
-            builtInName = (0, built_in_1.builtInId)(node.operator);
+        else if (nt === type_1.RType.BinaryOp || nt === type_1.RType.UnaryOp) {
+            builtInName = node_id_1.NodeId.toBuiltIn(node.operator);
         }
         else {
             return r_value_2.Top;

package/dataflow/fn/exceptions-of-function.d.ts

@@ -1,4 +1,4 @@
-import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { CallGraph } from '../graph/call-graph';
 import type { ControlDependency } from '../info';
 export interface ExceptionPoint {

package/dataflow/fn/exceptions-of-function.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.calculateExceptionsOfFunction = calculateExceptionsOfFunction;
+const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
 const vertex_1 = require("../graph/vertex");
 const built_in_1 = require("../environments/built-in");
 const CatchHandlers = new Set([built_in_1.BuiltInProcName.Try]);
@@ -35,7 +36,7 @@ function calculateExceptionsOfFunction(id, graph, knownThrower = {}) {
         if (!vtx) {
             continue;
         }
-        if ((0, built_in_1.isBuiltIn)(currentId)) {
+        if (node_id_1.NodeId.isBuiltIn(currentId)) {
             continue;
         }
         if (vtx.tag === vertex_1.VertexType.FunctionDefinition) {

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

@@ -1,6 +1,6 @@
 import { DataflowGraph } from './graph';
 import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexFunctionDefinition } from './vertex';
-import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { DefaultMap } from '../../util/collections/defaultmap';
 /**
  * A call graph is a dataflow graph where all vertices are function calls.

package/dataflow/graph/call-graph.js

@@ -6,6 +6,7 @@ exports.dropTransitiveEdges = dropTransitiveEdges;
 exports.computeCallGraph = computeCallGraph;
 const graph_1 = require("./graph");
 const vertex_1 = require("./vertex");
+const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
 const linker_1 = require("../internal/linker");
 const edge_1 = require("./edge");
 const built_in_1 = require("../environments/built-in");
@@ -176,7 +177,7 @@ function processCall(vtx, from, graph, result, state) {
     let addedTarget = false;
     let addedBiTarget = false;
     for (const tar of tars) {
-        if ((0, built_in_1.isBuiltIn)(tar)) {
+        if (node_id_1.NodeId.isBuiltIn(tar)) {
             result.addEdge(vid, tar, edge_1.EdgeType.Calls);
             addedTarget = true;
             addedBiTarget = true;
@@ -193,7 +194,7 @@ function processCall(vtx, from, graph, result, state) {
         for (const origs of vtx.origin) {
             if (origs.startsWith('builtin:')) {
                 addedTarget = true;
-                result.addEdge(vid, (0, built_in_1.builtInId)(origs.substring('builtin:'.length)), edge_1.EdgeType.Calls);
+                result.addEdge(vid, node_id_1.NodeId.toBuiltIn(origs.substring('builtin:'.length)), edge_1.EdgeType.Calls);
             }
         }
     }
@@ -237,7 +238,7 @@ function processUnknown(vtx, from, graph, result, state) {
             return;
         case vertex_1.VertexType.FunctionDefinition:
             if (from) {
-                result.addEdge(from, (0, built_in_1.builtInId)('function'), edge_1.EdgeType.Calls);
+                result.addEdge(from, node_id_1.NodeId.toBuiltIn('function'), edge_1.EdgeType.Calls);
             }
             return;
         default:

package/dataflow/graph/dataflowgraph-builder.d.ts

@@ -1,4 +1,4 @@
-import { type NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { AstIdMap } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { type DataflowFunctionFlowInformation, DataflowGraph, FunctionArgument } from './graph';
 import { type IEnvironment, type REnvironmentInformation } from '../environments/environment';

package/dataflow/graph/dataflowgraph-builder.js

@@ -48,21 +48,21 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
     defineFunction(id, exitPoints, subflow, info, asRoot = true) {
         return this.addVertexWithDefaultEnv({
             tag: vertex_1.VertexType.FunctionDefinition,
-            id: (0, node_id_1.normalizeIdToNumberIfPossible)(id),
+            id: node_id_1.NodeId.normalize(id),
             params: Object.fromEntries(info?.readParams ?? []),
             subflow: {
                 ...subflow,
-                entryPoint: (0, node_id_1.normalizeIdToNumberIfPossible)(subflow.entryPoint),
-                graph: new Set([...subflow.graph].map(node_id_1.normalizeIdToNumberIfPossible)),
-                out: subflow.out.map(o => ({ ...o, nodeId: (0, node_id_1.normalizeIdToNumberIfPossible)(o.nodeId), cds: o.cds?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })) })),
-                in: subflow.in.map(o => ({ ...o, nodeId: (0, node_id_1.normalizeIdToNumberIfPossible)(o.nodeId), cds: o.cds?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })) })),
-                unknownReferences: subflow.unknownReferences.map(o => ({ ...o, nodeId: (0, node_id_1.normalizeIdToNumberIfPossible)(o.nodeId), cds: o.cds?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })) })),
+                entryPoint: node_id_1.NodeId.normalize(subflow.entryPoint),
+                graph: new Set([...subflow.graph].map(node_id_1.NodeId.normalize)),
+                out: subflow.out.map(o => ({ ...o, nodeId: node_id_1.NodeId.normalize(o.nodeId), cds: o.cds?.map(c => ({ ...c, id: node_id_1.NodeId.normalize(c.id) })) })),
+                in: subflow.in.map(o => ({ ...o, nodeId: node_id_1.NodeId.normalize(o.nodeId), cds: o.cds?.map(c => ({ ...c, id: node_id_1.NodeId.normalize(c.id) })) })),
+                unknownReferences: subflow.unknownReferences.map(o => ({ ...o, nodeId: node_id_1.NodeId.normalize(o.nodeId), cds: o.cds?.map(c => ({ ...c, id: node_id_1.NodeId.normalize(c.id) })) })),
                 hooks: subflow.hooks ?? [],
             },
             mode: info?.mode,
-            exitPoints: exitPoints.map(e => typeof e === 'object' ? ({ ...e, nodeId: (0, node_id_1.normalizeIdToNumberIfPossible)(e.nodeId), cds: e.cds?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })) }) :
-                ({ nodeId: (0, node_id_1.normalizeIdToNumberIfPossible)(e), type: 0 /* ExitPointType.Default */, cds: undefined })),
-            cds: info?.cds?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })),
+            exitPoints: exitPoints.map(e => typeof e === 'object' ? ({ ...e, nodeId: node_id_1.NodeId.normalize(e.nodeId), cds: e.cds?.map(c => ({ ...c, id: node_id_1.NodeId.normalize(c.id) })) }) :
+                ({ nodeId: node_id_1.NodeId.normalize(e), type: 0 /* ExitPointType.Default */, cds: undefined })),
+            cds: info?.cds?.map(c => ({ ...c, id: node_id_1.NodeId.normalize(c.id) })),
             environment: info?.environment,
         }, asRoot);
     }
@@ -76,14 +76,14 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
      * (i.e., be a valid entry point), or is it nested (e.g., as part of a function definition)
      */
     call(id, name, args, info, asRoot = true) {
-        const onlyBuiltInAuto = info?.reads?.length === 1 && (0, built_in_1.isBuiltIn)(info?.reads[0]);
+        const onlyBuiltInAuto = info?.reads?.length === 1 && node_id_1.NodeId.isBuiltIn(info?.reads[0]);
         this.addVertexWithDefaultEnv({
             tag: vertex_1.VertexType.FunctionCall,
-            id: (0, node_id_1.normalizeIdToNumberIfPossible)(id),
+            id: node_id_1.NodeId.normalize(id),
             name,
-            args: args.map(a => a === r_function_call_1.EmptyArgument ? r_function_call_1.EmptyArgument : { ...a, nodeId: (0, node_id_1.normalizeIdToNumberIfPossible)(a.nodeId), cds: undefined }),
+            args: args.map(a => a === r_function_call_1.EmptyArgument ? r_function_call_1.EmptyArgument : { ...a, nodeId: node_id_1.NodeId.normalize(a.nodeId), cds: undefined }),
             environment: (info?.onlyBuiltIn || onlyBuiltInAuto) ? undefined : info?.environment ?? this.defaultEnvironment,
-            cds: info?.cds?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })),
+            cds: info?.cds?.map(c => ({ ...c, id: node_id_1.NodeId.normalize(c.id) })),
             onlyBuiltin: info?.onlyBuiltIn ?? onlyBuiltInAuto ?? false,
             origin: info?.origin ?? [(0, default_builtin_config_1.getDefaultProcessor)(name) ?? built_in_1.BuiltInProcName.Function],
             link: info?.link
@@ -133,9 +133,9 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
     defineVariable(id, name, info, asRoot = true) {
         this.addVertexWithDefaultEnv({
             tag: vertex_1.VertexType.VariableDefinition,
-            id: (0, node_id_1.normalizeIdToNumberIfPossible)(id),
+            id: node_id_1.NodeId.normalize(id),
             name,
-            cds: info?.cds?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })),
+            cds: info?.cds?.map(c => ({ ...c, id: node_id_1.NodeId.normalize(c.id) })),
         }, asRoot);
         if (info?.definedBy) {
             for (const def of info.definedBy) {
@@ -155,13 +155,13 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
     use(id, name, info, asRoot = true) {
         return this.addVertexWithDefaultEnv((0, objects_1.deepMergeObject)({
             tag: vertex_1.VertexType.Use,
-            id: (0, node_id_1.normalizeIdToNumberIfPossible)(id),
+            id: node_id_1.NodeId.normalize(id),
             name,
             cds: undefined,
             environment: undefined
         }, {
             ...info,
-            cds: info?.cds?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) }))
+            cds: info?.cds?.map(c => ({ ...c, id: node_id_1.NodeId.normalize(c.id) }))
         }), asRoot);
     }
     /**
@@ -174,8 +174,8 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
     constant(id, options, asRoot = true) {
         return this.addVertexWithDefaultEnv({
             tag: vertex_1.VertexType.Value,
-            id: (0, node_id_1.normalizeIdToNumberIfPossible)(id),
-            cds: options?.cds?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })),
+            id: node_id_1.NodeId.normalize(id),
+            cds: options?.cds?.map(c => ({ ...c, id: node_id_1.NodeId.normalize(c.id) })),
             environment: undefined
         }, asRoot);
     }
@@ -186,7 +186,7 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
             }
             return this;
         }
-        return this.addEdge((0, node_id_1.normalizeIdToNumberIfPossible)(from), (0, node_id_1.normalizeIdToNumberIfPossible)(to), type);
+        return this.addEdge(node_id_1.NodeId.normalize(from), node_id_1.NodeId.normalize(to), type);
     }
     async queryHelper(from, to, data, type) {
         let fromId;
@@ -344,7 +344,7 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
      * this is just an easier variant in case you working with a lot of functions this saves you a lot of `false` flags.
      */
     overwriteRootIds(ids) {
-        this.rootVertices = new Set(ids.map(node_id_1.normalizeIdToNumberIfPossible));
+        this.rootVertices = new Set(ids.map(node_id_1.NodeId.normalize));
         return this;
     }
 }

package/dataflow/graph/graph.d.ts

@@ -3,7 +3,7 @@ import type { DataflowInformation } from '../info';
 import { type DataflowGraphVertexArgument, type DataflowGraphVertexFunctionCall, type DataflowGraphVertexInfo } from './vertex';
 import { EmptyArgument } from '../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { BrandedIdentifier, IdentifierDefinition, IdentifierReference } from '../environments/identifier';
-import { type NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { type REnvironmentInformation } from '../environments/environment';
 import type { AstIdMap } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { LinkTo } from '../../queries/catalog/call-context-query/call-context-query-format';
@@ -88,12 +88,12 @@ export declare const FunctionArgument: {
      * ```
      * @see {@link isNotEmpty}
      */
-    readonly isEmpty: (this: void, arg: FunctionArgument) => arg is typeof EmptyArgument;
+    readonly isEmpty: (this: void, arg: unknown) => arg is typeof EmptyArgument;
     /**
      * Checks whether the given argument is not an empty argument.
-     * @see {@link isEmpty}
+     * @see {@link FunctionArgument.isEmpty}
      */
-    readonly isNotEmpty: (this: void, arg: FunctionArgument) => arg is NamedFunctionArgument | PositionalFunctionArgument;
+    readonly isNotEmpty: <T>(this: void, arg: T) => arg is Exclude<T, typeof EmptyArgument>;
     /**
      * Returns the reference of a non-empty argument.
      * @example
@@ -262,7 +262,7 @@ export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = Data
      */
     updateToFunctionCall(info: DataflowGraphVertexFunctionCall): void;
     /** If you do not pass the `to` node, this will just mark the node as maybe */
-    addControlDependency(from: NodeId, to?: NodeId, when?: boolean): this;
+    addControlDependency(from: NodeId, to: NodeId, when?: boolean): this;
     /** Marks the given node as having unknown side effects */
     markIdForUnknownSideEffects(id: NodeId, target?: LinkTo<RegExp | string>): this;
     /**