@eagleoutice/flowr 2.9.12 → 2.9.14

package/dataflow/environments/built-in.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuiltIns = exports.BuiltInEvalHandlerMapper = exports.BuiltInProcessorMapper = exports.BuiltInProcName = void 0;
+exports.BuiltIns = exports.BuiltInEvalHandlerMapper = exports.BuiltInProcessorMapper = void 0;
 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");
@@ -40,7 +40,8 @@ const built_in_recall_1 = require("../internal/process/functions/call/built-in/b
 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");
 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 built_in_proc_name_1 = require("./built-in-proc-name");
+function defaultBuiltInProcessor(name, args, rootId, data, { returnsNthArgument, useAsProcessor = built_in_proc_name_1.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.at(-1) : processedArguments[returnsNthArgument];
@@ -99,7 +100,7 @@ function defaultBuiltInProcessor(name, args, rootId, data, { returnsNthArgument,
     }
     return res;
 }
-function defaultBuiltInProcessorReadallArgs(name, args, rootId, data, { useAsProcessor = BuiltInProcName.Default, forceArgs }) {
+function defaultBuiltInProcessorReadallArgs(name, args, rootId, data, { useAsProcessor = built_in_proc_name_1.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) {
@@ -109,122 +110,38 @@ function defaultBuiltInProcessorReadallArgs(name, args, rootId, data, { useAsPro
     }
     return information;
 }
-/**
- * This contains all names of built-in function handlers and origins
- */
-var BuiltInProcName;
-(function (BuiltInProcName) {
-    /** for subsetting operations, see {@link processAccess} */
-    BuiltInProcName["Access"] = "builtin:access";
-    /** for the `*apply` family, see {@link processApply} */
-    BuiltInProcName["Apply"] = "builtin:apply";
-    /** for assignments like `<-` and `=`, see {@link processAssignment} */
-    BuiltInProcName["Assignment"] = "builtin:assignment";
-    /** for assignment like functions that may do additional work, see {@link processAssignmentLike} */
-    BuiltInProcName["AssignmentLike"] = "builtin:assignment-like";
-    /** for `break` calls */
-    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} */
-    BuiltInProcName["ExpressionList"] = "builtin:expression-list";
-    /** for `for` loops, see {@link processForLoop} */
-    BuiltInProcName["ForLoop"] = "builtin:for-loop";
-    /** We resolved a function call, similar to {@link BuiltInProcName#Default} */
-    BuiltInProcName["Function"] = "function";
-    /** for function definitions, see {@link processFunctionDefinition} */
-    BuiltInProcName["FunctionDefinition"] = "builtin:function-definition";
-    /** for `get` calls, see {@link processGet} */
-    BuiltInProcName["Get"] = "builtin:get";
-    /** for `if-then-else` constructs, see {@link processIfThenElse} */
-    BuiltInProcName["IfThenElse"] = "builtin:if-then-else";
-    /** for `library` and `require` calls, see {@link processLibrary} */
-    BuiltInProcName["Library"] = "builtin:library";
-    /** for `list` calls, see {@link processList} */
-    BuiltInProcName["List"] = "builtin:list";
-    /** for `local` calls, see {@link processLocal} */
-    BuiltInProcName["Local"] = "builtin:local";
-    /** for the pipe operators, see {@link processPipe} */
-    BuiltInProcName["Pipe"] = "builtin:pipe";
-    /** for `quote`, and other substituting calls, see {@link processQuote} */
-    BuiltInProcName["Quote"] = "builtin:quote";
-    /**
-     * for `recall` calls, see {@link processRecall}
-     */
-    BuiltInProcName["Recall"] = "builtin:recall";
-    /** for `on.exìt` and other hooks, see {@link processRegisterHook} */
-    BuiltInProcName["RegisterHook"] = "builtin:register-hook";
-    /** for `repeat` loops, see {@link processRepeatLoop} */
-    BuiltInProcName["RepeatLoop"] = "builtin:repeat-loop";
-    /** for replacement functions like `names<-`, see {@link processReplacementFunction} */
-    BuiltInProcName["Replacement"] = "builtin:replacement";
-    /** for `return` calls */
-    BuiltInProcName["Return"] = "builtin:return";
-    /** for `rm` calls, see {@link processRm} */
-    BuiltInProcName["Rm"] = "builtin:rm";
-    /** for `UseMethod` calls, see {@link processS3Dispatch} */
-    BuiltInProcName["S3Dispatch"] = "builtin:s3-dispatch";
-    /** for `NextMethod` calls, see {@link processS3Dispatch} */
-    BuiltInProcName["S3DispatchNext"] = "builtin:s3-dispatch-next";
-    /** for `new.generic` calls, see {@link processS7NewGeneric} */
-    BuiltInProcName["S7NewGeneric"] = "builtin:s7-new-generic";
-    /** for `S7_dispatch` calls (and their implicit creations), see {@link processS7Dispatch} */
-    BuiltInProcName["S7Dispatch"] = "builtin:s7-dispatch";
-    /** for `source` calls, see {@link processSourceCall} */
-    BuiltInProcName["Source"] = "builtin:source";
-    /** for special binary operators like `%x%`, see {@link processSpecialBinOp} */
-    BuiltInProcName["SpecialBinOp"] = "builtin:special-bin-op";
-    /** for `stop` calls */
-    BuiltInProcName["Stop"] = "builtin:stop";
-    /** for `stopifnot` calls, see {@link processStopIfNot} */
-    BuiltInProcName["StopIfNot"] = "builtin:stopifnot";
-    /** support for `:=` in subsetting assignments, see {@link processAccess} */
-    BuiltInProcName["TableAssignment"] = "table:assign";
-    /** for `try` calls, see {@link processTryCatch} */
-    BuiltInProcName["Try"] = "builtin:try";
-    /** for unnamed directly-linked function calls */
-    BuiltInProcName["Unnamed"] = "unnamed";
-    /** for vector construction calls, see {@link processVector} */
-    BuiltInProcName["Vector"] = "builtin:vector";
-    /** for `while` loops, see {@link processWhileLoop} */
-    BuiltInProcName["WhileLoop"] = "builtin:while-loop";
-})(BuiltInProcName || (exports.BuiltInProcName = BuiltInProcName = {}));
 exports.BuiltInProcessorMapper = {
-    [BuiltInProcName.Access]: built_in_access_1.processAccess,
-    [BuiltInProcName.Apply]: built_in_apply_1.processApply,
-    [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,
-    [BuiltInProcName.FunctionDefinition]: built_in_function_definition_1.processFunctionDefinition,
-    [BuiltInProcName.Get]: built_in_get_1.processGet,
-    [BuiltInProcName.IfThenElse]: built_in_if_then_else_1.processIfThenElse,
-    [BuiltInProcName.Library]: built_in_library_1.processLibrary,
-    [BuiltInProcName.List]: built_in_list_1.processList,
-    [BuiltInProcName.Local]: built_in_local_1.processLocal,
-    [BuiltInProcName.Pipe]: built_in_pipe_1.processPipe,
-    [BuiltInProcName.Quote]: built_in_quote_1.processQuote,
-    [BuiltInProcName.Recall]: built_in_recall_1.processRecall,
-    [BuiltInProcName.RegisterHook]: built_in_register_hook_1.processRegisterHook,
-    [BuiltInProcName.RepeatLoop]: built_in_repeat_loop_1.processRepeatLoop,
-    [BuiltInProcName.Replacement]: built_in_replacement_1.processReplacementFunction,
-    [BuiltInProcName.Rm]: built_in_rm_1.processRm,
-    [BuiltInProcName.S3Dispatch]: built_in_s_three_dispatch_1.processS3Dispatch,
-    [BuiltInProcName.S7NewGeneric]: built_in_s_seven_new_generic_1.processS7NewGeneric,
-    [BuiltInProcName.S7Dispatch]: built_in_s_seven_dispatch_1.processS7Dispatch,
-    [BuiltInProcName.Source]: built_in_source_1.processSourceCall,
-    [BuiltInProcName.SpecialBinOp]: built_in_special_bin_op_1.processSpecialBinOp,
-    [BuiltInProcName.StopIfNot]: built_in_stop_if_not_1.processStopIfNot,
-    [BuiltInProcName.Try]: built_in_try_catch_1.processTryCatch,
-    [BuiltInProcName.Vector]: built_in_vector_1.processVector,
-    [BuiltInProcName.WhileLoop]: built_in_while_loop_1.processWhileLoop,
+    [built_in_proc_name_1.BuiltInProcName.Access]: built_in_access_1.processAccess,
+    [built_in_proc_name_1.BuiltInProcName.Apply]: built_in_apply_1.processApply,
+    [built_in_proc_name_1.BuiltInProcName.Assignment]: built_in_assignment_1.processAssignment,
+    [built_in_proc_name_1.BuiltInProcName.AssignmentLike]: built_in_assignment_1.processAssignmentLike,
+    [built_in_proc_name_1.BuiltInProcName.Default]: defaultBuiltInProcessor,
+    [built_in_proc_name_1.BuiltInProcName.DefaultReadAllArgs]: defaultBuiltInProcessorReadallArgs,
+    [built_in_proc_name_1.BuiltInProcName.Eval]: built_in_eval_1.processEvalCall,
+    [built_in_proc_name_1.BuiltInProcName.ExpressionList]: built_in_expression_list_1.processExpressionList,
+    [built_in_proc_name_1.BuiltInProcName.ForLoop]: built_in_for_loop_1.processForLoop,
+    [built_in_proc_name_1.BuiltInProcName.FunctionDefinition]: built_in_function_definition_1.processFunctionDefinition,
+    [built_in_proc_name_1.BuiltInProcName.Get]: built_in_get_1.processGet,
+    [built_in_proc_name_1.BuiltInProcName.IfThenElse]: built_in_if_then_else_1.processIfThenElse,
+    [built_in_proc_name_1.BuiltInProcName.Library]: built_in_library_1.processLibrary,
+    [built_in_proc_name_1.BuiltInProcName.List]: built_in_list_1.processList,
+    [built_in_proc_name_1.BuiltInProcName.Local]: built_in_local_1.processLocal,
+    [built_in_proc_name_1.BuiltInProcName.Pipe]: built_in_pipe_1.processPipe,
+    [built_in_proc_name_1.BuiltInProcName.Quote]: built_in_quote_1.processQuote,
+    [built_in_proc_name_1.BuiltInProcName.Recall]: built_in_recall_1.processRecall,
+    [built_in_proc_name_1.BuiltInProcName.RegisterHook]: built_in_register_hook_1.processRegisterHook,
+    [built_in_proc_name_1.BuiltInProcName.RepeatLoop]: built_in_repeat_loop_1.processRepeatLoop,
+    [built_in_proc_name_1.BuiltInProcName.Replacement]: built_in_replacement_1.processReplacementFunction,
+    [built_in_proc_name_1.BuiltInProcName.Rm]: built_in_rm_1.processRm,
+    [built_in_proc_name_1.BuiltInProcName.S3Dispatch]: built_in_s_three_dispatch_1.processS3Dispatch,
+    [built_in_proc_name_1.BuiltInProcName.S7NewGeneric]: built_in_s_seven_new_generic_1.processS7NewGeneric,
+    [built_in_proc_name_1.BuiltInProcName.S7Dispatch]: built_in_s_seven_dispatch_1.processS7Dispatch,
+    [built_in_proc_name_1.BuiltInProcName.Source]: built_in_source_1.processSourceCall,
+    [built_in_proc_name_1.BuiltInProcName.SpecialBinOp]: built_in_special_bin_op_1.processSpecialBinOp,
+    [built_in_proc_name_1.BuiltInProcName.StopIfNot]: built_in_stop_if_not_1.processStopIfNot,
+    [built_in_proc_name_1.BuiltInProcName.Try]: built_in_try_catch_1.processTryCatch,
+    [built_in_proc_name_1.BuiltInProcName.Vector]: built_in_vector_1.processVector,
+    [built_in_proc_name_1.BuiltInProcName.WhileLoop]: built_in_while_loop_1.processWhileLoop,
 };
 exports.BuiltInEvalHandlerMapper = {
     'built-in:c': resolve_1.resolveAsVector,
@@ -278,8 +195,8 @@ class BuiltIns {
      * Registers all combinations of replacements
      */
     registerReplacementFunctions({ names, suffixes, assumePrimitive, config }) {
-        const replacer = exports.BuiltInProcessorMapper[BuiltInProcName.Replacement];
-        (0, assert_1.guard)(replacer !== undefined, () => `Processor for ${BuiltInProcName.Replacement} is undefined!`);
+        const replacer = exports.BuiltInProcessorMapper[built_in_proc_name_1.BuiltInProcName.Replacement];
+        (0, assert_1.guard)(replacer !== undefined, () => `Processor for ${built_in_proc_name_1.BuiltInProcName.Replacement} is undefined!`);
         for (const assignment of names) {
             for (const suffix of suffixes) {
                 const effectiveName = `${identifier_1.Identifier.getName(assignment)}${suffix}`;

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

@@ -3,9 +3,9 @@ import type { DataflowGraph } from '../graph/graph';
 import type { DataflowGraphVertexFunctionCall } from '../graph/vertex';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { CascadeAction } from '../../queries/catalog/call-context-query/cascade-action';
-import { BuiltInProcName } from './built-in';
 import { KnownHooks } from '../hooks';
 import { Identifier } from './identifier';
+import { BuiltInProcName } from './built-in-proc-name';
 export declare const GgPlotCreate: readonly ["ggplot", "ggplotly", "ggMarginal", "ggcorrplot", "ggseasonplot", "ggdendrogram", "qmap", "qplot", "quickplot", "autoplot", "grid.arrange", "fviz_pca_biplot", "fviz_pca", "fviz_pca_ind", "fviz_pca_var", "fviz_screeplot", "fviz_mca_biplot", "fviz_mca", "fviz_mca_ind", "fviz_mca_var", "fviz_cluster", "fviz_dend", "ggsurvplot"];
 export declare const TinyPlotCrate: readonly ["tinyplot", "plt"];
 export declare const GraphicsPlotCreate: string[];

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

@@ -5,10 +5,10 @@ exports.getDefaultProcessor = getDefaultProcessor;
 const identify_link_to_last_call_relation_1 = require("../../queries/catalog/call-context-query/identify-link-to-last-call-relation");
 const type_1 = require("../../r-bridge/lang-4.x/ast/model/type");
 const cascade_action_1 = require("../../queries/catalog/call-context-query/cascade-action");
-const built_in_1 = require("./built-in");
 const unnamed_call_handling_1 = require("../internal/process/functions/call/unnamed-call-handling");
 const hooks_1 = require("../hooks");
 const identifier_1 = require("./identifier");
+const built_in_proc_name_1 = require("./built-in-proc-name");
 exports.GgPlotCreate = [
     'ggplot', 'ggplotly', 'ggMarginal', 'ggcorrplot', 'ggseasonplot', 'ggdendrogram', 'qmap', 'qplot', 'quickplot', 'autoplot', 'grid.arrange',
     'fviz_pca_biplot', 'fviz_pca', 'fviz_pca_ind', 'fviz_pca_var', 'fviz_screeplot', 'fviz_mca_biplot', 'fviz_mca', 'fviz_mca_ind', 'fviz_mca_var', 'fviz_cluster', 'fviz_dend',
@@ -112,7 +112,7 @@ exports.DefaultBuiltinConfig = [
             'pdf', 'jpeg', 'png', 'windows', 'postscript', 'xfig', 'bitmap', 'pictex', 'cairo_pdf', 'svg', 'bmp', 'tiff', 'X11', 'quartz',
             'jitter'
         ],
-        processor: built_in_1.BuiltInProcName.DefaultReadAllArgs,
+        processor: built_in_proc_name_1.BuiltInProcName.DefaultReadAllArgs,
         config: {},
         assumePrimitive: true
     },
@@ -121,20 +121,20 @@ exports.DefaultBuiltinConfig = [
         names: [
             't', 'aperm' /* transpose function, permutation generation */
         ],
-        processor: built_in_1.BuiltInProcName.DefaultReadAllArgs,
+        processor: built_in_proc_name_1.BuiltInProcName.DefaultReadAllArgs,
         config: {},
         assumePrimitive: false
     },
-    { type: 'function', names: ['rm'], processor: built_in_1.BuiltInProcName.Rm, config: {}, assumePrimitive: true },
-    { type: 'function', names: ['options'], processor: built_in_1.BuiltInProcName.Default, config: { hasUnknownSideEffects: true, forceArgs: 'all' }, assumePrimitive: false },
-    { type: 'function', names: ['mapply', 'Mapply'], processor: built_in_1.BuiltInProcName.Apply, config: { indexOfFunction: 0, nameOfFunctionArgument: 'FUN' }, assumePrimitive: false },
-    { type: 'function', names: ['lapply', 'sapply', 'vapply'], processor: built_in_1.BuiltInProcName.Apply, config: { indexOfFunction: 1, nameOfFunctionArgument: 'FUN' }, assumePrimitive: false },
-    { type: 'function', names: ['Lapply', 'Sapply', 'Vapply'], processor: built_in_1.BuiltInProcName.Apply, config: { indexOfFunction: 1, nameOfFunctionArgument: 'FUN' }, assumePrimitive: false }, /* functool wrappers */
-    { type: 'function', names: ['apply', 'tapply', 'Tapply'], processor: built_in_1.BuiltInProcName.Apply, config: { indexOfFunction: 2, nameOfFunctionArgument: 'FUN' }, assumePrimitive: false },
-    { type: 'function', names: ['print', 'message', 'warning', 'warn', 'info'], processor: built_in_1.BuiltInProcName.Default, config: { returnsNthArgument: 0, forceArgs: 'all', hasUnknownSideEffects: { type: 'link-to-last-call', callName: /^sink$/ } }, assumePrimitive: false },
+    { type: 'function', names: ['rm'], processor: built_in_proc_name_1.BuiltInProcName.Rm, config: {}, assumePrimitive: true },
+    { type: 'function', names: ['options'], processor: built_in_proc_name_1.BuiltInProcName.Default, config: { hasUnknownSideEffects: true, forceArgs: 'all' }, assumePrimitive: false },
+    { type: 'function', names: ['mapply', 'Mapply'], processor: built_in_proc_name_1.BuiltInProcName.Apply, config: { indexOfFunction: 0, nameOfFunctionArgument: 'FUN' }, assumePrimitive: false },
+    { type: 'function', names: ['lapply', 'sapply', 'vapply'], processor: built_in_proc_name_1.BuiltInProcName.Apply, config: { indexOfFunction: 1, nameOfFunctionArgument: 'FUN' }, assumePrimitive: false },
+    { type: 'function', names: ['Lapply', 'Sapply', 'Vapply'], processor: built_in_proc_name_1.BuiltInProcName.Apply, config: { indexOfFunction: 1, nameOfFunctionArgument: 'FUN' }, assumePrimitive: false }, /* functool wrappers */
+    { type: 'function', names: ['apply', 'tapply', 'Tapply'], processor: built_in_proc_name_1.BuiltInProcName.Apply, config: { indexOfFunction: 2, nameOfFunctionArgument: 'FUN' }, assumePrimitive: false },
+    { type: 'function', names: ['print', 'message', 'warning', 'warn', 'info'], processor: built_in_proc_name_1.BuiltInProcName.Default, config: { returnsNthArgument: 0, forceArgs: 'all', hasUnknownSideEffects: { type: 'link-to-last-call', callName: /^sink$/ } }, assumePrimitive: false },
     // graphics base
     { type: 'function', names: exports.PlotCreate,
-        processor: built_in_1.BuiltInProcName.Default,
+        processor: built_in_proc_name_1.BuiltInProcName.Default,
         config: {
             forceArgs: 'all',
             hasUnknownSideEffects: {
@@ -151,7 +151,7 @@ exports.DefaultBuiltinConfig = [
         }, assumePrimitive: true },
     // graphics addons
     { type: 'function', names: PlotAddons,
-        processor: built_in_1.BuiltInProcName.Default, config: {
+        processor: built_in_proc_name_1.BuiltInProcName.Default, config: {
             forceArgs: 'all',
             treatAsFnCall: {
                 'facet_grid': ['labeller']
@@ -180,7 +180,7 @@ exports.DefaultBuiltinConfig = [
     {
         type: 'function',
         names: exports.GgPlotAddons,
-        processor: built_in_1.BuiltInProcName.Default,
+        processor: built_in_proc_name_1.BuiltInProcName.Default,
         config: {
             libFn: true,
             forceArgs: 'all',
@@ -193,7 +193,7 @@ exports.DefaultBuiltinConfig = [
     {
         type: 'function',
         names: exports.TinyPlotAddons,
-        processor: built_in_1.BuiltInProcName.Default,
+        processor: built_in_proc_name_1.BuiltInProcName.Default,
         config: {
             libFn: true,
             forceArgs: 'all',
@@ -206,7 +206,7 @@ exports.DefaultBuiltinConfig = [
     {
         type: 'function',
         names: ['image_write', 'image_capture', 'dev.capture', 'dev.off'],
-        processor: built_in_1.BuiltInProcName.Default,
+        processor: built_in_proc_name_1.BuiltInProcName.Default,
         config: {
             libFn: true,
             forceArgs: 'all',
@@ -216,12 +216,12 @@ exports.DefaultBuiltinConfig = [
             }
         }, assumePrimitive: true
     },
-    { type: 'function', names: ['('], processor: built_in_1.BuiltInProcName.Default, config: { returnsNthArgument: 0 }, assumePrimitive: true },
-    { type: 'function', names: ['load', 'load_all', 'setwd', 'set.seed'], processor: built_in_1.BuiltInProcName.Default, config: { hasUnknownSideEffects: true, forceArgs: [true] }, assumePrimitive: false },
-    { type: 'function', names: ['body', 'formals', 'environment'], processor: built_in_1.BuiltInProcName.Default, config: { hasUnknownSideEffects: true, forceArgs: [true] }, assumePrimitive: true },
+    { type: 'function', names: ['('], processor: built_in_proc_name_1.BuiltInProcName.Default, config: { returnsNthArgument: 0 }, assumePrimitive: true },
+    { type: 'function', names: ['load', 'load_all', 'setwd', 'set.seed'], processor: built_in_proc_name_1.BuiltInProcName.Default, config: { hasUnknownSideEffects: true, forceArgs: [true] }, assumePrimitive: false },
+    { type: 'function', names: ['body', 'formals', 'environment'], processor: built_in_proc_name_1.BuiltInProcName.Default, config: { hasUnknownSideEffects: true, forceArgs: [true] }, assumePrimitive: true },
     { type: 'function',
         names: ['.Call', '.External', '.C', '.Fortran'],
-        processor: built_in_1.BuiltInProcName.Default,
+        processor: built_in_proc_name_1.BuiltInProcName.Default,
         config: { hasUnknownSideEffects: true, forceArgs: [true],
             treatAsFnCall: {
                 '.Call': ['.NAME'],
@@ -230,64 +230,64 @@ exports.DefaultBuiltinConfig = [
                 '.Fortran': ['.NAME']
             }
         }, assumePrimitive: true },
-    { type: 'function', names: ['eval'], processor: built_in_1.BuiltInProcName.Eval, config: { includeFunctionCall: true }, assumePrimitive: true },
-    { type: 'function', names: ['cat'], processor: built_in_1.BuiltInProcName.Default, config: { forceArgs: 'all', hasUnknownSideEffects: { type: 'link-to-last-call', callName: /^sink$/ } }, assumePrimitive: false },
-    { type: 'function', names: ['switch'], processor: built_in_1.BuiltInProcName.Default, config: { forceArgs: [true] }, assumePrimitive: false },
-    { type: 'function', names: ['return'], processor: built_in_1.BuiltInProcName.Default, config: { returnsNthArgument: 0, cfg: 1 /* ExitPointType.Return */, useAsProcessor: built_in_1.BuiltInProcName.Return }, assumePrimitive: true },
+    { type: 'function', names: ['eval'], processor: built_in_proc_name_1.BuiltInProcName.Eval, config: { includeFunctionCall: true }, assumePrimitive: true },
+    { type: 'function', names: ['cat'], processor: built_in_proc_name_1.BuiltInProcName.Default, config: { forceArgs: 'all', hasUnknownSideEffects: { type: 'link-to-last-call', callName: /^sink$/ } }, assumePrimitive: false },
+    { type: 'function', names: ['switch'], processor: built_in_proc_name_1.BuiltInProcName.Default, config: { forceArgs: [true] }, assumePrimitive: false },
+    { type: 'function', names: ['return'], processor: built_in_proc_name_1.BuiltInProcName.Default, config: { returnsNthArgument: 0, cfg: 1 /* ExitPointType.Return */, useAsProcessor: built_in_proc_name_1.BuiltInProcName.Return }, assumePrimitive: true },
     {
         type: 'function',
         names: ['stop', 'abort', 'cli_abort', 'throw', 'stop_bad_type', 'stop_bad_element_type', 'stop_bad_element_length'],
-        processor: built_in_1.BuiltInProcName.Default,
-        config: { useAsProcessor: built_in_1.BuiltInProcName.Stop, cfg: 4 /* ExitPointType.Error */, forceArgs: ['all'] },
+        processor: built_in_proc_name_1.BuiltInProcName.Default,
+        config: { useAsProcessor: built_in_proc_name_1.BuiltInProcName.Stop, cfg: 4 /* ExitPointType.Error */, forceArgs: ['all'] },
         assumePrimitive: false
     },
-    { type: 'function', names: ['try'], processor: built_in_1.BuiltInProcName.Try, config: { block: 'expr', handlers: {} }, assumePrimitive: true },
-    { type: 'function', names: ['tryCatch', 'tryCatchLog'], processor: built_in_1.BuiltInProcName.Try, config: { block: 'expr', handlers: { error: 'error', finally: 'finally' } }, assumePrimitive: true },
-    { type: 'function', names: ['stopifnot', 'assert_that'], processor: built_in_1.BuiltInProcName.StopIfNot, config: {}, assumePrimitive: false },
-    { type: 'function', names: ['break'], processor: built_in_1.BuiltInProcName.Default, config: { useAsProcessor: built_in_1.BuiltInProcName.Break, cfg: 2 /* ExitPointType.Break */ }, assumePrimitive: false },
-    { type: 'function', names: ['next'], processor: built_in_1.BuiltInProcName.Default, config: { cfg: 3 /* ExitPointType.Next */ }, assumePrimitive: false },
-    { type: 'function', names: ['{'], processor: built_in_1.BuiltInProcName.ExpressionList, config: {}, assumePrimitive: true },
-    { type: 'function', names: ['source'], processor: built_in_1.BuiltInProcName.Source, config: { includeFunctionCall: true, forceFollow: false }, assumePrimitive: false },
-    { type: 'function', names: ['[', '[['], processor: built_in_1.BuiltInProcName.Access, config: { treatIndicesAsString: false }, assumePrimitive: true },
-    { type: 'function', names: ['$', '@'], processor: built_in_1.BuiltInProcName.Access, config: { treatIndicesAsString: true }, assumePrimitive: true },
-    { type: 'function', names: ['if'], processor: built_in_1.BuiltInProcName.IfThenElse, config: {}, assumePrimitive: true },
-    { type: 'function', names: ['ifelse', 'fifelse', 'IfElse'], processor: built_in_1.BuiltInProcName.IfThenElse, config: { args: { cond: 'test', yes: 'yes', no: 'no' } }, assumePrimitive: true },
-    { type: 'function', names: ['if_else'], processor: built_in_1.BuiltInProcName.IfThenElse, config: { args: { cond: 'condition', yes: 'true', no: 'false' } }, assumePrimitive: true },
-    { type: 'function', names: ['get'], processor: built_in_1.BuiltInProcName.Get, config: {}, assumePrimitive: false },
-    { type: 'function', names: [identifier_1.Identifier.make('library', 'base'), identifier_1.Identifier.make('require', 'base')], processor: built_in_1.BuiltInProcName.Library, config: {}, assumePrimitive: false },
-    { type: 'function', names: ['<-', '='], processor: built_in_1.BuiltInProcName.Assignment, config: { canBeReplacement: true }, assumePrimitive: true },
-    { type: 'function', names: [':='], processor: built_in_1.BuiltInProcName.Assignment, config: {}, assumePrimitive: true },
-    { type: 'function', names: ['assign', 'setValidity'], processor: built_in_1.BuiltInProcName.Assignment, config: { targetVariable: true, mayHaveMoreArgs: true }, assumePrimitive: true },
-    { type: 'function', names: ['setMethod'], processor: built_in_1.BuiltInProcName.AssignmentLike, config: { targetVariable: true, canBeReplacement: false, target: { idx: 0, name: 'f' }, source: { idx: 2, name: 'definition' }, modesForFn: ['s4'] }, assumePrimitive: true },
-    { type: 'function', names: ['delayedAssign'], processor: built_in_1.BuiltInProcName.Assignment, config: { quoteSource: true, targetVariable: true }, assumePrimitive: true },
-    { type: 'function', names: ['<<-'], processor: built_in_1.BuiltInProcName.Assignment, config: { superAssignment: true, canBeReplacement: true }, assumePrimitive: true },
-    { type: 'function', names: ['->'], processor: built_in_1.BuiltInProcName.Assignment, config: { swapSourceAndTarget: true, canBeReplacement: true }, assumePrimitive: true },
-    { type: 'function', names: ['->>'], processor: built_in_1.BuiltInProcName.Assignment, config: { superAssignment: true, swapSourceAndTarget: true, canBeReplacement: true }, assumePrimitive: true },
-    { type: 'function', names: ['&&', '&'], processor: built_in_1.BuiltInProcName.SpecialBinOp, config: { lazy: true, evalRhsWhen: true }, assumePrimitive: true },
-    { type: 'function', names: ['||', '|'], processor: built_in_1.BuiltInProcName.SpecialBinOp, config: { lazy: true, evalRhsWhen: false }, assumePrimitive: true },
-    { type: 'function', names: ['|>', '%>%'], processor: built_in_1.BuiltInProcName.Pipe, config: {}, assumePrimitive: true },
-    { type: 'function', names: ['function', '\\'], processor: built_in_1.BuiltInProcName.FunctionDefinition, config: {}, assumePrimitive: true },
-    { type: 'function', names: ['quote', 'substitute', 'bquote'], processor: built_in_1.BuiltInProcName.Quote, config: { quoteArgumentsWithIndex: 0 }, assumePrimitive: true },
-    { type: 'function', names: ['local'], processor: built_in_1.BuiltInProcName.Local, config: { args: { env: 'envir', expr: 'expr' } }, assumePrimitive: false },
-    { type: 'function', names: ['for'], processor: built_in_1.BuiltInProcName.ForLoop, config: {}, assumePrimitive: true },
-    { type: 'function', names: ['repeat'], processor: built_in_1.BuiltInProcName.RepeatLoop, config: {}, assumePrimitive: true },
-    { type: 'function', names: ['while'], processor: built_in_1.BuiltInProcName.WhileLoop, config: {}, assumePrimitive: true },
-    { type: 'function', names: ['do.call'], processor: built_in_1.BuiltInProcName.Apply, config: { indexOfFunction: 0, unquoteFunction: true }, assumePrimitive: true },
-    { type: 'function', names: ['UseMethod'], processor: built_in_1.BuiltInProcName.S3Dispatch, config: { args: { generic: 'generic', object: 'object' } }, assumePrimitive: true },
-    { type: 'function', names: ['NextMethod'], processor: built_in_1.BuiltInProcName.S3Dispatch, config: { args: { generic: 'generic', object: 'object' }, inferFromClosure: true }, assumePrimitive: true },
-    { type: 'function', names: ['new_generic'], processor: built_in_1.BuiltInProcName.S7NewGeneric, config: { args: { name: 'name', dispatchArg: 'dispatch_args', fun: 'fun' } }, assumePrimitive: true },
-    { type: 'function', names: ['setGeneric'], processor: built_in_1.BuiltInProcName.S7NewGeneric, config: { args: { name: 'name', dispatchArg: undefined, fun: 'fun' } }, assumePrimitive: true },
-    { type: 'function', names: ['S7_dispatch'], processor: built_in_1.BuiltInProcName.S7Dispatch, config: { libFn: true }, assumePrimitive: true },
-    { type: 'function', names: ['.Primitive', '.Internal'], processor: built_in_1.BuiltInProcName.Apply, config: { indexOfFunction: 0, unquoteFunction: true, resolveInEnvironment: 'global' }, assumePrimitive: true },
-    { type: 'function', names: ['interference'], processor: built_in_1.BuiltInProcName.Apply, config: { unquoteFunction: true, nameOfFunctionArgument: 'propensity_integrand', libFn: true }, assumePrimitive: false },
-    { type: 'function', names: ['ddply'], processor: built_in_1.BuiltInProcName.Apply, config: { unquoteFunction: true, indexOfFunction: 2, nameOfFunctionArgument: '.fun', libFn: true }, assumePrimitive: false },
-    { type: 'function', names: ['list'], processor: built_in_1.BuiltInProcName.List, config: {}, assumePrimitive: true },
-    { type: 'function', names: ['Recall'], processor: built_in_1.BuiltInProcName.Recall, config: { libFn: true }, assumePrimitive: false },
-    { type: 'function', names: ['c'], processor: built_in_1.BuiltInProcName.Vector, config: {}, assumePrimitive: true, evalHandler: 'built-in:c' },
+    { type: 'function', names: ['try'], processor: built_in_proc_name_1.BuiltInProcName.Try, config: { block: 'expr', handlers: {} }, assumePrimitive: true },
+    { type: 'function', names: ['tryCatch', 'tryCatchLog'], processor: built_in_proc_name_1.BuiltInProcName.Try, config: { block: 'expr', handlers: { error: 'error', finally: 'finally' } }, assumePrimitive: true },
+    { type: 'function', names: ['stopifnot', 'assert_that'], processor: built_in_proc_name_1.BuiltInProcName.StopIfNot, config: {}, assumePrimitive: false },
+    { type: 'function', names: ['break'], processor: built_in_proc_name_1.BuiltInProcName.Default, config: { useAsProcessor: built_in_proc_name_1.BuiltInProcName.Break, cfg: 2 /* ExitPointType.Break */ }, assumePrimitive: false },
+    { type: 'function', names: ['next'], processor: built_in_proc_name_1.BuiltInProcName.Default, config: { cfg: 3 /* ExitPointType.Next */ }, assumePrimitive: false },
+    { type: 'function', names: ['{'], processor: built_in_proc_name_1.BuiltInProcName.ExpressionList, config: {}, assumePrimitive: true },
+    { type: 'function', names: ['source'], processor: built_in_proc_name_1.BuiltInProcName.Source, config: { includeFunctionCall: true, forceFollow: false }, assumePrimitive: false },
+    { type: 'function', names: ['[', '[['], processor: built_in_proc_name_1.BuiltInProcName.Access, config: { treatIndicesAsString: false }, assumePrimitive: true },
+    { type: 'function', names: ['$', '@'], processor: built_in_proc_name_1.BuiltInProcName.Access, config: { treatIndicesAsString: true }, assumePrimitive: true },
+    { type: 'function', names: ['if'], processor: built_in_proc_name_1.BuiltInProcName.IfThenElse, config: {}, assumePrimitive: true },
+    { type: 'function', names: ['ifelse', 'fifelse', 'IfElse'], processor: built_in_proc_name_1.BuiltInProcName.IfThenElse, config: { args: { cond: 'test', yes: 'yes', no: 'no' } }, assumePrimitive: true },
+    { type: 'function', names: ['if_else'], processor: built_in_proc_name_1.BuiltInProcName.IfThenElse, config: { args: { cond: 'condition', yes: 'true', no: 'false' } }, assumePrimitive: true },
+    { type: 'function', names: ['get'], processor: built_in_proc_name_1.BuiltInProcName.Get, config: {}, assumePrimitive: false },
+    { type: 'function', names: [identifier_1.Identifier.make('library', 'base'), identifier_1.Identifier.make('require', 'base')], processor: built_in_proc_name_1.BuiltInProcName.Library, config: {}, assumePrimitive: false },
+    { type: 'function', names: ['<-', '='], processor: built_in_proc_name_1.BuiltInProcName.Assignment, config: { canBeReplacement: true }, assumePrimitive: true },
+    { type: 'function', names: [':='], processor: built_in_proc_name_1.BuiltInProcName.Assignment, config: {}, assumePrimitive: true },
+    { type: 'function', names: ['assign', 'setValidity'], processor: built_in_proc_name_1.BuiltInProcName.Assignment, config: { targetVariable: true, mayHaveMoreArgs: true }, assumePrimitive: true },
+    { type: 'function', names: ['setMethod'], processor: built_in_proc_name_1.BuiltInProcName.AssignmentLike, config: { targetVariable: true, canBeReplacement: false, target: { idx: 0, name: 'f' }, source: { idx: 2, name: 'definition' }, modesForFn: ['s4'] }, assumePrimitive: true },
+    { type: 'function', names: ['delayedAssign'], processor: built_in_proc_name_1.BuiltInProcName.Assignment, config: { quoteSource: true, targetVariable: true }, assumePrimitive: true },
+    { type: 'function', names: ['<<-'], processor: built_in_proc_name_1.BuiltInProcName.Assignment, config: { superAssignment: true, canBeReplacement: true }, assumePrimitive: true },
+    { type: 'function', names: ['->'], processor: built_in_proc_name_1.BuiltInProcName.Assignment, config: { swapSourceAndTarget: true, canBeReplacement: true }, assumePrimitive: true },
+    { type: 'function', names: ['->>'], processor: built_in_proc_name_1.BuiltInProcName.Assignment, config: { superAssignment: true, swapSourceAndTarget: true, canBeReplacement: true }, assumePrimitive: true },
+    { type: 'function', names: ['&&', '&'], processor: built_in_proc_name_1.BuiltInProcName.SpecialBinOp, config: { lazy: true, evalRhsWhen: true }, assumePrimitive: true },
+    { type: 'function', names: ['||', '|'], processor: built_in_proc_name_1.BuiltInProcName.SpecialBinOp, config: { lazy: true, evalRhsWhen: false }, assumePrimitive: true },
+    { type: 'function', names: ['|>', '%>%'], processor: built_in_proc_name_1.BuiltInProcName.Pipe, config: {}, assumePrimitive: true },
+    { type: 'function', names: ['function', '\\'], processor: built_in_proc_name_1.BuiltInProcName.FunctionDefinition, config: {}, assumePrimitive: true },
+    { type: 'function', names: ['quote', 'substitute', 'bquote'], processor: built_in_proc_name_1.BuiltInProcName.Quote, config: { quoteArgumentsWithIndex: 0 }, assumePrimitive: true },
+    { type: 'function', names: ['local'], processor: built_in_proc_name_1.BuiltInProcName.Local, config: { args: { env: 'envir', expr: 'expr' } }, assumePrimitive: false },
+    { type: 'function', names: ['for'], processor: built_in_proc_name_1.BuiltInProcName.ForLoop, config: {}, assumePrimitive: true },
+    { type: 'function', names: ['repeat'], processor: built_in_proc_name_1.BuiltInProcName.RepeatLoop, config: {}, assumePrimitive: true },
+    { type: 'function', names: ['while'], processor: built_in_proc_name_1.BuiltInProcName.WhileLoop, config: {}, assumePrimitive: true },
+    { type: 'function', names: ['do.call'], processor: built_in_proc_name_1.BuiltInProcName.Apply, config: { indexOfFunction: 0, unquoteFunction: true }, assumePrimitive: true },
+    { type: 'function', names: ['UseMethod'], processor: built_in_proc_name_1.BuiltInProcName.S3Dispatch, config: { args: { generic: 'generic', object: 'object' } }, assumePrimitive: true },
+    { type: 'function', names: ['NextMethod'], processor: built_in_proc_name_1.BuiltInProcName.S3Dispatch, config: { args: { generic: 'generic', object: 'object' }, inferFromClosure: true }, assumePrimitive: true },
+    { type: 'function', names: ['new_generic'], processor: built_in_proc_name_1.BuiltInProcName.S7NewGeneric, config: { args: { name: 'name', dispatchArg: 'dispatch_args', fun: 'fun' } }, assumePrimitive: true },
+    { type: 'function', names: ['setGeneric'], processor: built_in_proc_name_1.BuiltInProcName.S7NewGeneric, config: { args: { name: 'name', dispatchArg: undefined, fun: 'fun' } }, assumePrimitive: true },
+    { type: 'function', names: ['S7_dispatch'], processor: built_in_proc_name_1.BuiltInProcName.S7Dispatch, config: { libFn: true }, assumePrimitive: true },
+    { type: 'function', names: ['.Primitive', '.Internal'], processor: built_in_proc_name_1.BuiltInProcName.Apply, config: { indexOfFunction: 0, unquoteFunction: true, resolveInEnvironment: 'global' }, assumePrimitive: true },
+    { type: 'function', names: ['interference'], processor: built_in_proc_name_1.BuiltInProcName.Apply, config: { unquoteFunction: true, nameOfFunctionArgument: 'propensity_integrand', libFn: true }, assumePrimitive: false },
+    { type: 'function', names: ['ddply'], processor: built_in_proc_name_1.BuiltInProcName.Apply, config: { unquoteFunction: true, indexOfFunction: 2, nameOfFunctionArgument: '.fun', libFn: true }, assumePrimitive: false },
+    { type: 'function', names: ['list'], processor: built_in_proc_name_1.BuiltInProcName.List, config: {}, assumePrimitive: true },
+    { type: 'function', names: ['Recall'], processor: built_in_proc_name_1.BuiltInProcName.Recall, config: { libFn: true }, assumePrimitive: false },
+    { type: 'function', names: ['c'], processor: built_in_proc_name_1.BuiltInProcName.Vector, config: {}, assumePrimitive: true, evalHandler: 'built-in:c' },
     {
         type: 'function',
         names: ['setnames', 'setNames', 'setkey', 'setkeyv', 'setindex', 'setindexv', 'setattr'],
-        processor: built_in_1.BuiltInProcName.Assignment,
+        processor: built_in_proc_name_1.BuiltInProcName.Assignment,
         config: {
             canBeReplacement: false,
             targetVariable: false,
@@ -306,7 +306,7 @@ exports.DefaultBuiltinConfig = [
             /* file creation/removal */
             'dir.create', 'dir_create', 'Sys.chmod', 'unlink', 'file.remove', 'file.rename', 'file.copy', 'file.link', 'file.append', 'Sys.junction'
         ],
-        processor: built_in_1.BuiltInProcName.Default,
+        processor: built_in_proc_name_1.BuiltInProcName.Default,
         config: { hasUnknownSideEffects: true },
         assumePrimitive: false
     },
@@ -317,14 +317,14 @@ exports.DefaultBuiltinConfig = [
             /* downloader and installer functions (R, devtools, BiocManager) */
             'library.dynam', 'install.packages', 'install', 'install_github', 'install_gitlab', 'install_bitbucket', 'install_url', 'install_git', 'install_svn', 'install_local', 'install_version', 'update_packages',
         ],
-        processor: built_in_1.BuiltInProcName.Default,
+        processor: built_in_proc_name_1.BuiltInProcName.Default,
         config: { hasUnknownSideEffects: true, libFn: true },
         assumePrimitive: false
     },
     {
         type: 'function',
         names: ['on.exit'],
-        processor: built_in_1.BuiltInProcName.RegisterHook,
+        processor: built_in_proc_name_1.BuiltInProcName.RegisterHook,
         config: {
             hook: hooks_1.KnownHooks.OnFnExit,
             args: {
@@ -367,13 +367,13 @@ exports.DefaultBuiltinConfig = [
  */
 function getDefaultProcessor(name) {
     if (name.startsWith(unnamed_call_handling_1.UnnamedFunctionCallPrefix)) {
-        return built_in_1.BuiltInProcName.Unnamed;
+        return built_in_proc_name_1.BuiltInProcName.Unnamed;
     }
     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)));
     if (fn?.type === 'replacement') {
-        return built_in_1.BuiltInProcName.Replacement;
+        return built_in_proc_name_1.BuiltInProcName.Replacement;
     }
-    return fn?.processor === built_in_1.BuiltInProcName.DefaultReadAllArgs ? built_in_1.BuiltInProcName.Default : fn?.processor;
+    return fn?.processor === built_in_proc_name_1.BuiltInProcName.DefaultReadAllArgs ? built_in_proc_name_1.BuiltInProcName.Default : fn?.processor;
 }
 //# sourceMappingURL=default-builtin-config.js.map

package/dataflow/environments/identifier.d.ts

@@ -33,6 +33,7 @@ export type Identifier = BrandedIdentifier | [id: BrandedIdentifier, namespace:
  * ```
  */
 export declare const Identifier: {
+    readonly name: "Identifier";
     /**
      * Create an identifier from its name and optional namespace.
      * Please note that for `internal` to count, a namespace must be provided!

package/dataflow/environments/identifier.js

@@ -17,6 +17,7 @@ const dotDotDotAccess = /^\.\.\d+$/;
  * ```
  */
 exports.Identifier = {
+    name: 'Identifier',
     /**
      * Create an identifier from its name and optional namespace.
      * Please note that for `internal` to count, a namespace must be provided!

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

@@ -34,7 +34,7 @@ function getFunctionCallAlias(sourceId, dataflow, environment) {
         return undefined;
     }
     const defs = (0, resolve_by_name_1.resolveByName)(identifier, environment, identifier_1.ReferenceType.Function);
-    if (defs === undefined || defs.length !== 1) {
+    if (defs?.length !== 1) {
         return undefined;
     }
     return [sourceId];
@@ -206,7 +206,7 @@ function trackAliasInEnvironments(identifier, environment, { blocked, idMap, res
             }
         }
     }
-    if (values.size == 0) {
+    if (values.size === 0) {
         return r_value_1.Top;
     }
     return (0, set_constants_1.setFrom)(...values);
@@ -246,18 +246,7 @@ function trackAliasInEnvironments(identifier, environment, { blocked, idMap, res
     }
 });
 function isNestedInLoop(node, ast) {
-    const parent = node?.info.parent;
-    if (node === undefined || !parent) {
-        return false;
-    }
-    const parentNode = ast.get(parent);
-    if (parentNode === undefined) {
-        return false;
-    }
-    if (parentNode.type === type_1.RType.WhileLoop || parentNode.type === type_1.RType.RepeatLoop || parentNode.type === type_1.RType.ForLoop) {
-        return true;
-    }
-    return isNestedInLoop(parentNode, ast);
+    return model_1.RNode.iterateParents(node, ast).some(model_1.RLoopConstructs.is);
 }
 /**
  * Please use {@link resolveIdToValue}
@@ -311,12 +300,14 @@ function trackAliasesInGraph(id, graph, ctx, idMap) {
         }
         const isFn = t === vertex_1.VertexType.FunctionCall;
         const outgoingEdges = graph.outgoingEdges(id) ?? [];
+        let foundRetuns = false;
         // travel all read and defined-by edges
         for (const [targetId, { types }] of outgoingEdges) {
             if (isFn) {
                 if (types === edge_1.EdgeType.Returns || types === edge_1.EdgeType.DefinedByOnCall || types === edge_1.EdgeType.DefinedBy) {
                     queue.add(targetId, baseEnvironment, cleanFingerprint, false);
                 }
+                foundRetuns ||= edge_1.DfEdge.includesType({ types }, edge_1.EdgeType.Returns);
                 continue;
             }
             // currently, they have to be exact!
@@ -324,6 +315,9 @@ function trackAliasesInGraph(id, graph, ctx, idMap) {
                 queue.add(targetId, baseEnvironment, cleanFingerprint, false);
             }
         }
+        if (isFn && !foundRetuns) {
+            return r_value_1.Top;
+        }
     }
     if (forceTop || resultIds.length === 0) {
         return r_value_1.Top;
@@ -332,10 +326,13 @@ function trackAliasesInGraph(id, graph, ctx, idMap) {
     for (const id of resultIds) {
         const node = idMap.get(id);
         if (node !== undefined) {
+            if (node.info.role === "param-v" /* RoleInParent.ParameterDefaultValue */ || model_1.RNode.iterateParents(node, idMap).some(p => p.info.role === "param-v" /* RoleInParent.ParameterDefaultValue */)) {
+                return r_value_1.Top;
+            }
             values.add((0, general_1.valueFromRNodeConstant)(node));
         }
     }
-    return (0, set_constants_1.setFrom)(...values);
+    return values.size === 0 ? r_value_1.Top : (0, set_constants_1.setFrom)(...values);
 }
 /**
  * Please use {@link resolveIdToValue}

package/dataflow/eval/resolve/resolve.js

@@ -9,7 +9,6 @@ const r_function_call_1 = require("../../../r-bridge/lang-4.x/ast/model/nodes/r-
 const type_1 = require("../../../r-bridge/lang-4.x/ast/model/type");
 const r_value_1 = require("../../../util/r-value");
 const built_in_1 = require("../../environments/built-in");
-const dfg_get_origin_1 = require("../../origin/dfg-get-origin");
 const interval_constants_1 = require("../values/intervals/interval-constants");
 const logical_constants_1 = require("../values/logical/logical-constants");
 const r_value_2 = require("../values/r-value");
@@ -19,6 +18,7 @@ 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");
+const df_helper_1 = require("../../graph/df-helper");
 /**
  * Helper function used by {@link resolveIdToValue}, please use that instead, if
  * you want to resolve the value of an identifier / node
@@ -42,7 +42,7 @@ function resolveNode({ resolve, node, ctx, blocked, environment, graph, idMap })
         return { type: 'function-definition' };
     }
     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];
+        const origin = df_helper_1.Dataflow.origin(graph, node.info.id)?.[0];
         if (origin === undefined || origin.type !== 3 /* OriginType.BuiltInFunctionOrigin */) {
             return r_value_2.Top;
         }

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

@@ -1,6 +1,6 @@
 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';
+import type { CallGraph } from '../graph/call-graph';
 export interface ExceptionPoint {
     id: NodeId;
     cds?: readonly ControlDependency[];