@eagleoutice/flowr 2.8.6 → 2.8.8

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

@@ -5,6 +5,7 @@ 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");
 exports.GgPlotCreate = [
@@ -89,7 +90,7 @@ exports.GgPlotAddons = [
 const PlotAddons = exports.GraphicsPlotAddons.concat(exports.GgPlotImplicitAddons, ...exports.PlotFunctionsWithAddParam);
 const RegexConvIn = /[-/\\^$*+?.()|[\]{}]/g;
 function toRegex(n) {
-    return new RegExp(`^(${Array.from(new Set(n)).map(s => s.replace(RegexConvIn, '\\$&')).filter(s => s.length > 0).join('|')})$`);
+    return new RegExp(`^(${Array.from(new Set(n), s => s.replaceAll(RegexConvIn, String.raw `\$&`)).filter(s => s.length > 0).join('|')})$`);
 }
 /**
  * Contains the built-in definitions recognized by flowR
@@ -110,7 +111,7 @@ exports.DefaultBuiltinConfig = [
             'pdf', 'jpeg', 'png', 'windows', 'postscript', 'xfig', 'bitmap', 'pictex', 'cairo_pdf', 'svg', 'bmp', 'tiff', 'X11', 'quartz',
             'jitter'
         ],
-        processor: 'builtin:default',
+        processor: built_in_1.BuiltInProcName.Default,
         config: { readAllArguments: true },
         assumePrimitive: true
     },
@@ -119,20 +120,20 @@ exports.DefaultBuiltinConfig = [
         names: [
             't', 'aperm' /* transpose function, permutation generation */
         ],
-        processor: 'builtin:default',
+        processor: built_in_1.BuiltInProcName.Default,
         config: { readAllArguments: true },
         assumePrimitive: false
     },
-    { type: 'function', names: ['rm'], processor: 'builtin:rm', config: {}, assumePrimitive: true },
-    { type: 'function', names: ['options'], processor: 'builtin:default', config: { hasUnknownSideEffects: true, forceArgs: 'all' }, assumePrimitive: false },
-    { type: 'function', names: ['mapply', 'Mapply'], processor: 'builtin:apply', config: { indexOfFunction: 0, nameOfFunctionArgument: 'FUN' }, assumePrimitive: false },
-    { type: 'function', names: ['lapply', 'sapply', 'vapply'], processor: 'builtin:apply', config: { indexOfFunction: 1, nameOfFunctionArgument: 'FUN' }, assumePrimitive: false },
-    { type: 'function', names: ['Lapply', 'Sapply', 'Vapply'], processor: 'builtin:apply', config: { indexOfFunction: 1, nameOfFunctionArgument: 'FUN' }, assumePrimitive: false }, /* functool wrappers */
-    { type: 'function', names: ['apply', 'tapply', 'Tapply'], processor: 'builtin:apply', config: { indexOfFunction: 2, nameOfFunctionArgument: 'FUN' }, assumePrimitive: false },
-    { type: 'function', names: ['print', 'message', 'warning', 'warn', 'info'], processor: 'builtin:default', config: { returnsNthArgument: 0, forceArgs: 'all', hasUnknownSideEffects: { type: 'link-to-last-call', callName: /^sink$/ } }, 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 },
     // graphics base
     { type: 'function', names: exports.PlotCreate,
-        processor: 'builtin:default',
+        processor: built_in_1.BuiltInProcName.Default,
         config: {
             forceArgs: 'all',
             hasUnknownSideEffects: {
@@ -149,7 +150,7 @@ exports.DefaultBuiltinConfig = [
         }, assumePrimitive: true },
     // graphics addons
     { type: 'function', names: PlotAddons,
-        processor: 'builtin:default', config: {
+        processor: built_in_1.BuiltInProcName.Default, config: {
             forceArgs: 'all',
             treatAsFnCall: {
                 'facet_grid': ['labeller']
@@ -178,7 +179,7 @@ exports.DefaultBuiltinConfig = [
     {
         type: 'function',
         names: exports.GgPlotAddons,
-        processor: 'builtin:default',
+        processor: built_in_1.BuiltInProcName.Default,
         config: {
             libFn: true,
             forceArgs: 'all',
@@ -191,7 +192,7 @@ exports.DefaultBuiltinConfig = [
     {
         type: 'function',
         names: exports.TinyPlotAddons,
-        processor: 'builtin:default',
+        processor: built_in_1.BuiltInProcName.Default,
         config: {
             libFn: true,
             forceArgs: 'all',
@@ -204,7 +205,7 @@ exports.DefaultBuiltinConfig = [
     {
         type: 'function',
         names: ['image_write', 'image_capture', 'dev.capture', 'dev.off'],
-        processor: 'builtin:default',
+        processor: built_in_1.BuiltInProcName.Default,
         config: {
             libFn: true,
             forceArgs: 'all',
@@ -214,12 +215,12 @@ exports.DefaultBuiltinConfig = [
             }
         }, assumePrimitive: true
     },
-    { type: 'function', names: ['('], processor: 'builtin:default', config: { returnsNthArgument: 0 }, assumePrimitive: true },
-    { type: 'function', names: ['load', 'load_all', 'setwd', 'set.seed'], processor: 'builtin:default', config: { hasUnknownSideEffects: true, forceArgs: [true] }, assumePrimitive: false },
-    { type: 'function', names: ['body', 'formals', 'environment'], processor: 'builtin:default', config: { hasUnknownSideEffects: true, forceArgs: [true] }, 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: ['.Call', '.External', '.C', '.Fortran'],
-        processor: 'builtin:default',
+        processor: built_in_1.BuiltInProcName.Default,
         config: { hasUnknownSideEffects: true, forceArgs: [true],
             treatAsFnCall: {
                 '.Call': ['.NAME'],
@@ -228,56 +229,60 @@ exports.DefaultBuiltinConfig = [
                 '.Fortran': ['.NAME']
             }
         }, assumePrimitive: true },
-    { type: 'function', names: ['eval'], processor: 'builtin:eval', config: { includeFunctionCall: true }, assumePrimitive: true },
-    { type: 'function', names: ['cat'], processor: 'builtin:default', config: { forceArgs: 'all', hasUnknownSideEffects: { type: 'link-to-last-call', callName: /^sink$/ } }, assumePrimitive: false },
-    { type: 'function', names: ['switch'], processor: 'builtin:default', config: { forceArgs: [true] }, assumePrimitive: false },
-    { type: 'function', names: ['return'], processor: 'builtin:default', config: { returnsNthArgument: 0, cfg: 1 /* ExitPointType.Return */, useAsProcessor: 'builtin:return' }, 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: 'builtin:return' }, assumePrimitive: true },
     {
         type: 'function',
         names: ['stop', 'abort', 'cli_abort', 'throw', 'stop_bad_type', 'stop_bad_element_type', 'stop_bad_element_length'],
-        processor: 'builtin:default',
-        config: { useAsProcessor: 'builtin:stop', cfg: 4 /* ExitPointType.Error */, forceArgs: ['all'] },
+        processor: built_in_1.BuiltInProcName.Default,
+        config: { useAsProcessor: built_in_1.BuiltInProcName.Stop, cfg: 4 /* ExitPointType.Error */, forceArgs: ['all'] },
         assumePrimitive: false
     },
-    { type: 'function', names: ['try'], processor: 'builtin:try', config: { block: 'expr', handlers: {} }, assumePrimitive: true },
-    { type: 'function', names: ['tryCatch', 'tryCatchLog'], processor: 'builtin:try', config: { block: 'expr', handlers: { error: 'error', finally: 'finally' } }, assumePrimitive: true },
-    { type: 'function', names: ['stopifnot'], processor: 'builtin:stopifnot', config: {}, assumePrimitive: false },
-    { type: 'function', names: ['break'], processor: 'builtin:default', config: { useAsProcessor: 'builtin:break', cfg: 2 /* ExitPointType.Break */ }, assumePrimitive: false },
-    { type: 'function', names: ['next'], processor: 'builtin:default', config: { cfg: 3 /* ExitPointType.Next */ }, assumePrimitive: false },
-    { type: 'function', names: ['{'], processor: 'builtin:expression-list', config: {}, assumePrimitive: true },
-    { type: 'function', names: ['source'], processor: 'builtin:source', config: { includeFunctionCall: true, forceFollow: false }, assumePrimitive: false },
-    { type: 'function', names: ['[', '[['], processor: 'builtin:access', config: { treatIndicesAsString: false }, assumePrimitive: true },
-    { type: 'function', names: ['$', '@'], processor: 'builtin:access', config: { treatIndicesAsString: true }, assumePrimitive: true },
-    { type: 'function', names: ['if', 'ifelse'], processor: 'builtin:if-then-else', config: {}, assumePrimitive: true },
-    { type: 'function', names: ['get'], processor: 'builtin:get', config: {}, assumePrimitive: false },
-    { type: 'function', names: ['library', 'require'], processor: 'builtin:library', config: {}, assumePrimitive: false },
-    { type: 'function', names: ['<-', '='], processor: 'builtin:assignment', config: { canBeReplacement: true }, assumePrimitive: true },
-    { type: 'function', names: [':='], processor: 'builtin:assignment', config: {}, assumePrimitive: true },
-    { type: 'function', names: ['assign', 'setGeneric', 'setValidity'], processor: 'builtin:assignment', config: { targetVariable: true, mayHaveMoreArgs: true }, assumePrimitive: true },
-    { type: 'function', names: ['setMethod'], processor: 'builtin:assignment-like', config: { targetVariable: true, canBeReplacement: false, target: { idx: 0, name: 'f' }, source: { idx: 2, name: 'definition' } }, assumePrimitive: true },
-    { type: 'function', names: ['delayedAssign'], processor: 'builtin:assignment', config: { quoteSource: true, targetVariable: true }, assumePrimitive: true },
-    { type: 'function', names: ['<<-'], processor: 'builtin:assignment', config: { superAssignment: true, canBeReplacement: true }, assumePrimitive: true },
-    { type: 'function', names: ['->'], processor: 'builtin:assignment', config: { swapSourceAndTarget: true, canBeReplacement: true }, assumePrimitive: true },
-    { type: 'function', names: ['->>'], processor: 'builtin:assignment', config: { superAssignment: true, swapSourceAndTarget: true, canBeReplacement: true }, assumePrimitive: true },
-    { type: 'function', names: ['&&', '&'], processor: 'builtin:special-bin-op', config: { lazy: true, evalRhsWhen: true }, assumePrimitive: true },
-    { type: 'function', names: ['||', '|'], processor: 'builtin:special-bin-op', config: { lazy: true, evalRhsWhen: false }, assumePrimitive: true },
-    { type: 'function', names: ['|>', '%>%'], processor: 'builtin:pipe', config: {}, assumePrimitive: true },
-    { type: 'function', names: ['function', '\\'], processor: 'builtin:function-definition', config: {}, assumePrimitive: true },
-    { type: 'function', names: ['quote', 'substitute', 'bquote'], processor: 'builtin:quote', config: { quoteArgumentsWithIndex: 0 }, assumePrimitive: true },
-    { type: 'function', names: ['for'], processor: 'builtin:for-loop', config: {}, assumePrimitive: true },
-    { type: 'function', names: ['repeat'], processor: 'builtin:repeat-loop', config: {}, assumePrimitive: true },
-    { type: 'function', names: ['while'], processor: 'builtin:while-loop', config: {}, assumePrimitive: true },
-    { type: 'function', names: ['do.call'], processor: 'builtin:apply', config: { indexOfFunction: 0, unquoteFunction: true }, assumePrimitive: true },
-    { type: 'function', names: ['UseMethod', 'NextMethod'], processor: 'builtin:apply', config: { indexOfFunction: 0, unquoteFunction: true, resolveInEnvironment: 'global' }, assumePrimitive: true },
-    { type: 'function', names: ['.Primitive', '.Internal'], processor: 'builtin:apply', config: { indexOfFunction: 0, unquoteFunction: true, resolveInEnvironment: 'global' }, assumePrimitive: true },
-    { type: 'function', names: ['interference'], processor: 'builtin:apply', config: { unquoteFunction: true, nameOfFunctionArgument: 'propensity_integrand', libFn: true }, assumePrimitive: false },
-    { type: 'function', names: ['ddply'], processor: 'builtin:apply', config: { unquoteFunction: true, indexOfFunction: 2, nameOfFunctionArgument: '.fun', libFn: true }, assumePrimitive: false },
-    { type: 'function', names: ['list'], processor: 'builtin:list', config: {}, assumePrimitive: true },
-    { type: 'function', names: ['c'], processor: 'builtin:vector', config: {}, assumePrimitive: true, evalHandler: 'builtin:c' },
+    { 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'], processor: built_in_1.BuiltInProcName.StopIfNot, config: {}, assumePrimitive: false },
+    { type: 'function', names: ['break'], processor: built_in_1.BuiltInProcName.Default, config: { useAsProcessor: 'builtin: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: ['library', 'require'], 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', 'setGeneric', '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' } }, 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: ['NextMethod'], processor: built_in_1.BuiltInProcName.Apply, config: { indexOfFunction: 0, unquoteFunction: true, resolveInEnvironment: 'global' }, assumePrimitive: true },
+    { type: 'function', names: ['UseMethod'], processor: built_in_1.BuiltInProcName.S3Dispatch, config: { args: { generic: 'generic', object: 'object' } }, 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: ['c'], processor: built_in_1.BuiltInProcName.Vector, config: {}, assumePrimitive: true, evalHandler: 'builtin:c' },
     {
         type: 'function',
         names: ['setnames', 'setNames', 'setkey', 'setkeyv', 'setindex', 'setindexv', 'setattr'],
-        processor: 'builtin:assignment',
+        processor: built_in_1.BuiltInProcName.Assignment,
         config: {
             canBeReplacement: false,
             targetVariable: false,
@@ -296,7 +301,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: 'builtin:default',
+        processor: built_in_1.BuiltInProcName.Default,
         config: { hasUnknownSideEffects: true },
         assumePrimitive: false
     },
@@ -307,14 +312,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: 'builtin:default',
+        processor: built_in_1.BuiltInProcName.Default,
         config: { hasUnknownSideEffects: true, libFn: true },
         assumePrimitive: false
     },
     {
         type: 'function',
         names: ['on.exit'],
-        processor: 'builtin:register-hook',
+        processor: built_in_1.BuiltInProcName.RegisterHook,
         config: {
             hook: hooks_1.KnownHooks.OnFnExit,
             args: {
@@ -348,10 +353,10 @@ exports.DefaultBuiltinConfig = [
  */
 function getDefaultProcessor(name) {
     if (name.startsWith(unnamed_call_handling_1.UnnamedFunctionCallPrefix)) {
-        return 'unnamed';
+        return built_in_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)));
-    return fn?.type === 'replacement' ? 'builtin:replacement' : fn?.processor;
+    return fn?.type === 'replacement' ? built_in_1.BuiltInProcName.Replacement : fn?.processor;
 }
 //# sourceMappingURL=default-builtin-config.js.map

package/dataflow/environments/diff.js

@@ -23,7 +23,7 @@ function diffIdentifierReferences(a, b, info) {
     if (a.nodeId !== b.nodeId) {
         info.report.addComment(`${info.position}Different nodeIds: ${info.leftname}: ${a.nodeId} vs. ${info.rightname}: ${b.nodeId}`);
     }
-    (0, info_1.diffControlDependencies)(a.controlDependencies, b.controlDependencies, info);
+    (0, info_1.diffControlDependencies)(a.cds, b.cds, info);
 }
 function diffMemory(a, b, info) {
     for (const [key, value] of a.memory) {
@@ -44,7 +44,7 @@ function diffMemory(a, b, info) {
             if (aVal.nodeId !== bVal.nodeId) {
                 info.report.addComment(`${info.position}Different ids for ${key}. ${info.leftname}: ${aVal.nodeId} vs. ${info.rightname}: ${bVal.nodeId}`);
             }
-            (0, info_1.diffControlDependencies)(aVal.controlDependencies, bVal.controlDependencies, { ...info, position: `${info.position} For ${key}. ` });
+            (0, info_1.diffControlDependencies)(aVal.cds, bVal.cds, { ...info, position: `${info.position} For ${key}. ` });
             if (aVal.definedAt !== bVal.definedAt) {
                 info.report.addComment(`${info.position}Different definition ids (definedAt) for ${key} (${aVal.nodeId}). ${info.leftname}: ${aVal.definedAt} vs. ${info.rightname}: ${bVal.definedAt}`);
             }

package/dataflow/environments/environment.js

@@ -51,7 +51,7 @@ class Environment {
             .map(([k, v]) => [k,
             v.map(s => ({
                 ...s,
-                controlDependencies: s.controlDependencies?.slice()
+                cds: s.cds?.slice()
             }))
         ]));
         return clone;
@@ -65,7 +65,7 @@ class Environment {
         const { name } = definition;
         const newEnvironment = this.clone(false);
         // When there are defined indices, merge the definitions
-        if (definition.controlDependencies === undefined && !pointerTracking) {
+        if (definition.cds === undefined && !pointerTracking) {
             newEnvironment.memory.set(name, [definition]);
         }
         else {
@@ -73,7 +73,7 @@ class Environment {
             const inGraphDefinition = definition;
             if (pointerTracking &&
                 existing !== undefined &&
-                inGraphDefinition.controlDependencies === undefined) {
+                inGraphDefinition.cds === undefined) {
                 if (inGraphDefinition.indicesCollection !== undefined) {
                     const defs = (0, define_1.mergeDefinitionsForPointer)(existing, inGraphDefinition);
                     newEnvironment.memory.set(name, defs);
@@ -83,7 +83,7 @@ class Environment {
                     existing.push(definition);
                 }
             }
-            else if (existing === undefined || definition.controlDependencies === undefined) {
+            else if (existing === undefined || definition.cds === undefined) {
                 newEnvironment.memory.set(name, [definition]);
             }
             else {
@@ -124,7 +124,7 @@ class Environment {
         }
         const map = new Map(this.memory);
         for (const [key, values] of other.memory) {
-            const hasMaybe = applyCds === undefined ? values.length === 0 || values.some(v => v.controlDependencies !== undefined) : true;
+            const hasMaybe = applyCds === undefined ? values.length === 0 || values.some(v => v.cds !== undefined) : true;
             if (hasMaybe) {
                 const old = map.get(key);
                 // we need to make a copy to avoid side effects for old reference in other environments
@@ -141,7 +141,7 @@ class Environment {
                     else {
                         updatedOld.push({
                             ...v,
-                            controlDependencies: v.controlDependencies ? applyCds.concat(v.controlDependencies) : applyCds.slice()
+                            cds: v.cds ? applyCds.concat(v.cds) : applyCds.slice()
                         });
                     }
                 }
@@ -186,7 +186,7 @@ class Environment {
         if (definition !== undefined) {
             this.memory.delete(name);
             this.cache?.delete(name);
-            cont = !definition.every(d => (0, info_1.happensInEveryBranch)(d.controlDependencies));
+            cont = !definition.every(d => (0, info_1.happensInEveryBranch)(d.cds));
         }
         if (cont) {
             this.parent.remove(name);

package/dataflow/environments/identifier.d.ts

@@ -33,7 +33,9 @@ export declare enum ReferenceType {
     /** The identifier is defined by a built-in value/constant */
     BuiltInConstant = 64,
     /** The identifier is defined by a built-in function */
-    BuiltInFunction = 128
+    BuiltInFunction = 128,
+    /** Prefix to identify S3 methods, use this, to for example dispatch a call to `f` which will then link to `f.*` */
+    S3MethodPrefix = 256
 }
 /** Reverse mapping of the reference types so you can get the name from the bitmask (useful for debugging) */
 export declare const ReferenceTypeReverseMapping: Map<ReferenceType, string>;
@@ -74,7 +76,7 @@ export interface IdentifierReference {
      * If the reference is only effective, if, for example, an if-then-else condition is true, this references the root of the `if`.
      * As a hacky intermediate solution (until we have pointer-analysis), an empty array may indicate a `maybe` which is due to pointer access (e.g., in `a[x] <- 3`).
      */
-    controlDependencies?: ControlDependency[] | undefined;
+    cds?: ControlDependency[] | undefined;
 }
 /**
  * The definition of an {@link Identifier|identifier} within the {@link DataflowGraph|graph}.

package/dataflow/environments/identifier.js

@@ -32,6 +32,8 @@ var ReferenceType;
     ReferenceType[ReferenceType["BuiltInConstant"] = 64] = "BuiltInConstant";
     /** The identifier is defined by a built-in function */
     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";
 })(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/reference-to-maybe.d.ts

@@ -3,11 +3,11 @@ import type { DataflowGraph } from '../graph/graph';
 import type { ControlDependency } from '../info';
 import type { REnvironmentInformation } from './environment';
 /**
- * Marks the reference as maybe (i.e., as controlled by a set of {@link IdentifierReference#controlDependencies|control dependencies}).
+ * Marks the reference as maybe (i.e., as controlled by a set of {@link IdentifierReference#cds|control dependencies}).
  */
 export declare function makeReferenceMaybe(ref: IdentifierReference, graph: DataflowGraph, environments: REnvironmentInformation, includeDefs: boolean, defaultCd?: ControlDependency[] | undefined): IdentifierReference;
 /**
- * Marks all references as maybe (i.e., as controlled by a set of {@link IdentifierReference#controlDependencies|control dependencies}).
+ * Marks all references as maybe (i.e., as controlled by a set of {@link IdentifierReference#cds|control dependencies}).
  * @see {@link makeReferenceMaybe}
  */
 export declare function makeAllMaybe(references: readonly IdentifierReference[] | undefined, graph: DataflowGraph, environments: REnvironmentInformation, includeDefs: boolean, applyCds?: ControlDependency[] | undefined): IdentifierReference[];

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

@@ -18,43 +18,43 @@ function concatCdsUnique(target, toAdd) {
     }
 }
 /**
- * Marks the reference as maybe (i.e., as controlled by a set of {@link IdentifierReference#controlDependencies|control dependencies}).
+ * Marks the reference as maybe (i.e., as controlled by a set of {@link IdentifierReference#cds|control dependencies}).
  */
 function makeReferenceMaybe(ref, graph, environments, includeDefs, defaultCd = undefined) {
     if (includeDefs) {
         const definitions = ref.name ? (0, resolve_by_name_1.resolveByName)(ref.name, environments, ref.type) : undefined;
         for (const definition of definitions ?? []) {
             if (definition.type !== identifier_1.ReferenceType.BuiltInFunction && definition.type !== identifier_1.ReferenceType.BuiltInConstant) {
-                if (definition.controlDependencies) {
-                    appToCdsUnique(definition.controlDependencies, defaultCd);
+                if (definition.cds) {
+                    appToCdsUnique(definition.cds, defaultCd);
                 }
                 else {
-                    definition.controlDependencies = defaultCd ? Array.from(defaultCd) : [];
+                    definition.cds = defaultCd ? Array.from(defaultCd) : [];
                 }
             }
         }
     }
     const node = graph.getVertex(ref.nodeId, true);
     if (node) {
-        if (node.controlDependencies) {
-            appToCdsUnique(node.controlDependencies, defaultCd);
+        if (node.cds) {
+            appToCdsUnique(node.cds, defaultCd);
         }
         else {
-            node.controlDependencies = defaultCd ? Array.from(defaultCd) : [];
+            node.cds = defaultCd ? Array.from(defaultCd) : [];
         }
     }
-    if (ref.controlDependencies) {
+    if (ref.cds) {
         if (defaultCd) {
-            return { ...ref, controlDependencies: concatCdsUnique(ref.controlDependencies, defaultCd) };
+            return { ...ref, cds: concatCdsUnique(ref.cds, defaultCd) };
         }
     }
     else {
-        return { ...ref, controlDependencies: defaultCd ? Array.from(defaultCd) : [] };
+        return { ...ref, cds: defaultCd ? Array.from(defaultCd) : [] };
     }
     return ref;
 }
 /**
- * Marks all references as maybe (i.e., as controlled by a set of {@link IdentifierReference#controlDependencies|control dependencies}).
+ * Marks all references as maybe (i.e., as controlled by a set of {@link IdentifierReference#cds|control dependencies}).
  * @see {@link makeReferenceMaybe}
  */
 function makeAllMaybe(references, graph, environments, includeDefs, applyCds = undefined) {

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

@@ -19,7 +19,8 @@ const TargetTypePredicate = {
     [identifier_1.ReferenceType.Parameter]: () => true,
     [identifier_1.ReferenceType.Argument]: () => true,
     [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.BuiltInFunction]: ({ type }) => (0, identifier_1.isReferenceType)(type, BuiltInFunctionTargetTypes),
+    [identifier_1.ReferenceType.S3MethodPrefix]: ({ 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.
@@ -38,15 +39,25 @@ function resolveByName(name, environment, target) {
     let definitions = undefined;
     const wantedType = TargetTypePredicate[target];
     do {
-        const definition = current.memory.get(name);
-        if (definition !== undefined) {
+        let definition;
+        if (target === identifier_1.ReferenceType.S3MethodPrefix) {
+            // S3 method prefixes only resolve to functions
+            definition = current.memory.entries()
+                .filter(([defName]) => defName.startsWith(name + '.'))
+                .flatMap(([, defs]) => defs)
+                .toArray();
+        }
+        else {
+            definition = current.memory.get(name);
+        }
+        if (definition !== undefined && definition.length > 0) {
             const filtered = definition.filter(wantedType);
-            if (filtered.length === definition.length && definition.every(d => (0, info_1.happensInEveryBranch)(d.controlDependencies))) {
+            if (filtered.length === definition.length && (target !== identifier_1.ReferenceType.Function || definition.every(d => d.type !== identifier_1.ReferenceType.Parameter)) && definition.every(d => (0, info_1.happensInEveryBranch)(d.cds))) {
                 return definition;
             }
             else if (filtered.length > 0) {
                 if (definitions) {
-                    definitions = definitions.concat(filtered);
+                    definitions.push(...filtered);
                 }
                 else {
                     definitions = filtered;
@@ -76,7 +87,7 @@ function resolveByNameAnyType(name, environment) {
     do {
         const definition = current.memory.get(name);
         if (definition) {
-            if (definition.every(d => (0, info_1.happensInEveryBranch)(d.controlDependencies))) {
+            if (definition.every(d => (0, info_1.happensInEveryBranch)(d.cds))) {
                 environment.current.cache ??= new Map();
                 environment.current.cache?.set(name, definition);
                 return definition;

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

@@ -282,7 +282,7 @@ function trackAliasesInGraph(id, graph, ctx, idMap) {
             continue;
         }
         const [vertex, outgoingEdges] = res;
-        const cds = vertex.controlDependencies;
+        const cds = vertex.cds;
         for (const cd of cds ?? []) {
             const target = graph.idMap?.get(cd.id);
             if (target === undefined) {

package/dataflow/eval/resolve/resolve.js

@@ -16,7 +16,7 @@ const r_value_2 = require("../values/r-value");
 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_consatnts_1 = require("../values/scalar/scalar-consatnts");
+const scalar_constants_1 = require("../values/scalar/scalar-constants");
 /**
  * Helper function used by {@link resolveIdToValue}, please use that instead, if
  * you want to resolve the value of an identifier / node
@@ -113,7 +113,7 @@ function resolveAsSeq(resolve, operator, ctx, environment, graph, idMap) {
     const leftValue = (0, r_value_1.unliftRValue)(leftArg);
     const rightValue = (0, r_value_1.unliftRValue)(rightArg);
     if ((0, r_value_1.isRNumberValue)(leftValue) && (0, r_value_1.isRNumberValue)(rightValue)) {
-        return (0, vector_constants_1.vectorFrom)(createNumberSequence(leftValue, rightValue).map(scalar_consatnts_1.liftScalar));
+        return (0, vector_constants_1.vectorFrom)(createNumberSequence(leftValue, rightValue).map(scalar_constants_1.liftScalar));
     }
     return r_value_2.Top;
 }
@@ -138,10 +138,10 @@ function resolveAsPlus(resolve, operator, ctx, environment, graph, idMap) {
     const arg = (0, alias_tracking_1.resolveIdToValue)(operator.operand, resolveInfo);
     const argValue = (0, r_value_1.unliftRValue)(arg);
     if ((0, r_value_1.isRNumberValue)(argValue)) {
-        return (0, scalar_consatnts_1.liftScalar)(argValue);
+        return (0, scalar_constants_1.liftScalar)(argValue);
     }
     else if (Array.isArray(argValue) && argValue.every(r_value_1.isRNumberValue)) {
-        return (0, vector_constants_1.vectorFrom)(argValue.map(scalar_consatnts_1.liftScalar));
+        return (0, vector_constants_1.vectorFrom)(argValue.map(scalar_constants_1.liftScalar));
     }
     return r_value_2.Top;
 }
@@ -166,10 +166,10 @@ function resolveAsMinus(resolve, operator, ctx, environment, graph, idMap) {
     const arg = (0, alias_tracking_1.resolveIdToValue)(operator.operand, resolveInfo);
     const argValue = (0, r_value_1.unliftRValue)(arg);
     if ((0, r_value_1.isRNumberValue)(argValue)) {
-        return (0, scalar_consatnts_1.liftScalar)({ ...argValue, num: -argValue.num });
+        return (0, scalar_constants_1.liftScalar)({ ...argValue, num: -argValue.num });
     }
     else if (Array.isArray(argValue) && argValue.every(r_value_1.isRNumberValue)) {
-        return (0, vector_constants_1.vectorFrom)(argValue.map(element => (0, scalar_consatnts_1.liftScalar)({ ...element, num: -element.num })));
+        return (0, vector_constants_1.vectorFrom)(argValue.map(element => (0, scalar_constants_1.liftScalar)({ ...element, num: -element.num })));
     }
     return r_value_2.Top;
 }

package/dataflow/eval/values/intervals/interval-constants.js

@@ -3,16 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.intervalFrom = intervalFrom;
 exports.intervalFromValues = intervalFromValues;
 const r_value_1 = require("../r-value");
-const scalar_consatnts_1 = require("../scalar/scalar-consatnts");
+const scalar_constants_1 = require("../scalar/scalar-constants");
 /**
  *
  */
 function intervalFrom(start, end = start, startInclusive = true, endInclusive = true) {
-    return intervalFromValues(typeof start === 'number' ? (0, scalar_consatnts_1.getScalarFromInteger)(start) : (0, scalar_consatnts_1.liftScalar)(start), typeof end === 'number' ? (0, scalar_consatnts_1.getScalarFromInteger)(end) : (0, scalar_consatnts_1.liftScalar)(end), startInclusive, endInclusive);
+    return intervalFromValues(typeof start === 'number' ? (0, scalar_constants_1.getScalarFromInteger)(start) : (0, scalar_constants_1.liftScalar)(start), typeof end === 'number' ? (0, scalar_constants_1.getScalarFromInteger)(end) : (0, scalar_constants_1.liftScalar)(end), startInclusive, endInclusive);
 }
 function shiftNum(v) {
     if ((0, r_value_1.isBottom)(v) || (0, r_value_1.isTop)(v)) {
-        return (0, scalar_consatnts_1.liftScalar)(v);
+        return (0, scalar_constants_1.liftScalar)(v);
     }
     else {
         return v;

package/dataflow/eval/values/scalar/{scalar-consatnts.d.ts → scalar-constants.d.ts}

@@ -1,11 +1,11 @@
 import { type Lift, type ValueNumber } from '../r-value';
 import type { RNumberValue } from '../../../../r-bridge/lang-4.x/convert-values';
 /**
- *
+ * Given a (ts) number, return a scalar R number value.
  */
 export declare function getScalarFromInteger(num: number, markedAsInt?: boolean, complexNumber?: boolean): ValueNumber<RNumberValue>;
 /**
- *
+ * Take a lifted R number value and wrap it into a ValueNumber.
  */
 export declare function liftScalar(value: Lift<RNumberValue>): ValueNumber;
 export declare const ValueIntegerOne: ValueNumber<RNumberValue>;

package/dataflow/eval/values/scalar/{scalar-consatnts.js → scalar-constants.js}

@@ -5,7 +5,7 @@ exports.getScalarFromInteger = getScalarFromInteger;
 exports.liftScalar = liftScalar;
 const r_value_1 = require("../r-value");
 /**
- *
+ * Given a (ts) number, return a scalar R number value.
  */
 function getScalarFromInteger(num, markedAsInt = Number.isInteger(num), complexNumber = false) {
     return {
@@ -18,7 +18,7 @@ function getScalarFromInteger(num, markedAsInt = Number.isInteger(num), complexN
     };
 }
 /**
- *
+ * Take a lifted R number value and wrap it into a ValueNumber.
  */
 function liftScalar(value) {
     return {
@@ -38,4 +38,4 @@ exports.ValueNumberEpsilon = getScalarFromInteger(epsilon, false);
 exports.ValueNumberOneHalf = getScalarFromInteger(0.5, false);
 exports.ValueIntegerTop = liftScalar(r_value_1.Top);
 exports.ValueIntegerBottom = liftScalar(r_value_1.Bottom);
-//# sourceMappingURL=scalar-consatnts.js.map
+//# sourceMappingURL=scalar-constants.js.map