@eagleoutice/flowr 2.8.5 → 2.8.7

package/dataflow/environments/built-in.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuiltIns = exports.BuiltInEvalHandlerMapper = exports.BuiltInProcessorMapper = void 0;
+exports.BuiltIns = exports.BuiltInEvalHandlerMapper = exports.BuiltInProcessorMapper = exports.BuiltInProcName = void 0;
 exports.builtInId = builtInId;
 exports.isBuiltIn = isBuiltIn;
 exports.dropBuiltInPrefix = dropBuiltInPrefix;
@@ -36,6 +36,8 @@ const resolve_1 = require("../eval/resolve/resolve");
 const built_in_stop_if_not_1 = require("../internal/process/functions/call/built-in/built-in-stop-if-not");
 const built_in_try_catch_1 = require("../internal/process/functions/call/built-in/built-in-try-catch");
 const built_in_register_hook_1 = require("../internal/process/functions/call/built-in/built-in-register-hook");
+const built_in_local_1 = require("../internal/process/functions/call/built-in/built-in-local");
+const built_in_s_three_dispatch_1 = require("../internal/process/functions/call/built-in/built-in-s-three-dispatch");
 /**
  * Generate a built-in id for the given name
  */
@@ -56,7 +58,7 @@ function dropBuiltInPrefix(name) {
     return name.slice(builtInPrefixLength);
 }
 function defaultBuiltInProcessor(name, args, rootId, data, { returnsNthArgument, useAsProcessor, forceArgs, readAllArguments, cfg, hasUnknownSideEffects, treatAsFnCall }) {
-    const activeProcessor = useAsProcessor ?? 'builtin:default';
+    const activeProcessor = useAsProcessor ?? BuiltInProcName.Default;
     const { information: res, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs, origin: activeProcessor });
     if (returnsNthArgument !== undefined) {
         const arg = returnsNthArgument === 'last' ? processedArguments[args.length - 1] : processedArguments[returnsNthArgument];
@@ -72,11 +74,11 @@ function defaultBuiltInProcessor(name, args, rootId, data, { returnsNthArgument,
         }
     }
     if (hasUnknownSideEffects) {
-        if (typeof hasUnknownSideEffects !== 'boolean') {
-            (0, unknown_side_effect_1.handleUnknownSideEffect)(res.graph, res.environment, rootId, hasUnknownSideEffects);
+        if (typeof hasUnknownSideEffects === 'boolean') {
+            (0, unknown_side_effect_1.handleUnknownSideEffect)(res.graph, res.environment, rootId);
         }
         else {
-            (0, unknown_side_effect_1.handleUnknownSideEffect)(res.graph, res.environment, rootId);
+            (0, unknown_side_effect_1.handleUnknownSideEffect)(res.graph, res.environment, rootId, hasUnknownSideEffects);
         }
     }
     const fnCallNames = treatAsFnCall?.[name.content];
@@ -104,43 +106,117 @@ function defaultBuiltInProcessor(name, args, rootId, data, { returnsNthArgument,
                     args: [],
                     environment: data.environment,
                     onlyBuiltin: false,
-                    controlDependencies: data.controlDependencies,
+                    cds: data.cds,
                     origin: [activeProcessor]
                 });
             }
         }
     }
     if (cfg !== undefined) {
-        res.exitPoints.push({ type: cfg, nodeId: rootId, controlDependencies: data.controlDependencies });
+        res.exitPoints.push({ type: cfg, nodeId: rootId, cds: data.cds });
     }
     return res;
 }
+/**
+ * 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";
+    /** 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 `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 `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 = {
-    'builtin:access': built_in_access_1.processAccess,
-    'builtin:apply': built_in_apply_1.processApply,
-    'builtin:assignment': built_in_assignment_1.processAssignment,
-    'builtin:assignment-like': built_in_assignment_1.processAssignmentLike,
-    'builtin:default': defaultBuiltInProcessor,
-    'builtin:eval': built_in_eval_1.processEvalCall,
-    'builtin:expression-list': built_in_expression_list_1.processExpressionList,
-    'builtin:for-loop': built_in_for_loop_1.processForLoop,
-    'builtin:function-definition': built_in_function_definition_1.processFunctionDefinition,
-    'builtin:get': built_in_get_1.processGet,
-    'builtin:if-then-else': built_in_if_then_else_1.processIfThenElse,
-    'builtin:library': built_in_library_1.processLibrary,
-    'builtin:list': built_in_list_1.processList,
-    'builtin:pipe': built_in_pipe_1.processPipe,
-    'builtin:quote': built_in_quote_1.processQuote,
-    'builtin:register-hook': built_in_register_hook_1.processRegisterHook,
-    'builtin:repeat-loop': built_in_repeat_loop_1.processRepeatLoop,
-    'builtin:replacement': built_in_replacement_1.processReplacementFunction,
-    'builtin:rm': built_in_rm_1.processRm,
-    'builtin:source': built_in_source_1.processSourceCall,
-    'builtin:special-bin-op': built_in_special_bin_op_1.processSpecialBinOp,
-    'builtin:stopifnot': built_in_stop_if_not_1.processStopIfNot,
-    'builtin:try': built_in_try_catch_1.processTryCatch,
-    'builtin:vector': built_in_vector_1.processVector,
-    'builtin:while-loop': built_in_while_loop_1.processWhileLoop,
+    [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.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.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.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,
 };
 exports.BuiltInEvalHandlerMapper = {
     'built-in:c': resolve_1.resolveAsVector,
@@ -150,7 +226,7 @@ exports.BuiltInEvalHandlerMapper = {
 };
 class BuiltIns {
     /**
-     * Register a built-in constant (like `NULL` or `TRUE`) to the given {@link builtIns}
+     * Register a built-in constant (like `NULL` or `TRUE`) to the given {@link BuiltIns}
      */
     registerBuiltInConstant({ names, value, assumePrimitive }) {
         for (const name of names) {
@@ -158,7 +234,7 @@ class BuiltIns {
             const d = [{
                     type: identifier_1.ReferenceType.BuiltInConstant,
                     definedAt: id,
-                    controlDependencies: undefined,
+                    cds: undefined,
                     value,
                     name,
                     nodeId: id
@@ -167,18 +243,18 @@ class BuiltIns {
         }
     }
     /**
-     * Register a built-in function (like `print` or `c`) to the given {@link builtIns}
+     * Register a built-in function (like `print` or `c`) to the given {@link BuiltIns}
      */
     registerBuiltInFunctions({ names, processor, config, assumePrimitive }) {
+        (0, assert_1.guard)(processor !== undefined, () => `Processor for ${JSON.stringify(names)} is undefined, maybe you have an import loop? You may run 'npm run detect-circular-deps' - although by far not all are bad`);
         const mappedProcessor = exports.BuiltInProcessorMapper[processor];
         (0, assert_1.guard)(mappedProcessor !== undefined, () => `Processor for ${processor} is undefined! Please pass a valid builtin name ${JSON.stringify(Object.keys(exports.BuiltInProcessorMapper))}!`);
         for (const name of names) {
-            (0, assert_1.guard)(processor !== undefined, `Processor for ${name} is undefined, maybe you have an import loop? You may run 'npm run detect-circular-deps' - although by far not all are bad`);
             const id = builtInId(name);
             const d = [{
                     type: identifier_1.ReferenceType.BuiltInFunction,
                     definedAt: id,
-                    controlDependencies: undefined,
+                    cds: undefined,
                     /* eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-argument */
                     processor: (name, args, rootId, data) => mappedProcessor(name, args, rootId, data, config),
                     config,
@@ -208,7 +284,7 @@ class BuiltIns {
                             makeMaybe: true
                         },
                         name: effectiveName,
-                        controlDependencies: undefined,
+                        cds: undefined,
                         nodeId: id
                     }];
                 this.set(effectiveName, d, assumePrimitive);
@@ -216,7 +292,7 @@ class BuiltIns {
         }
     }
     /**
-     * Register a single {@link BuiltInDefinition} to the given memories in {@link builtIns}
+     * Register a single {@link BuiltInDefinition} to the given memories in {@link BuiltIns}
      */
     registerBuiltInDefinition(definition) {
         switch (definition.type) {