@eagleoutice/flowr 2.8.6 → 2.8.7

package/control-flow/useless-loop.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loopyFunctions = void 0;
 exports.onlyLoopsOnce = onlyLoopsOnce;
+const built_in_1 = require("../dataflow/environments/built-in");
 const alias_tracking_1 = require("../dataflow/eval/resolve/alias-tracking");
 const general_1 = require("../dataflow/eval/values/general");
 const r_value_1 = require("../dataflow/eval/values/r-value");
@@ -10,7 +11,7 @@ const info_1 = require("../dataflow/info");
 const r_function_call_1 = require("../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const assert_1 = require("../util/assert");
 const semantic_cfg_guided_visitor_1 = require("./semantic-cfg-guided-visitor");
-exports.loopyFunctions = new Set(['builtin:for-loop', 'builtin:while-loop', 'builtin:repeat-loop']);
+exports.loopyFunctions = new Set([built_in_1.BuiltInProcName.ForLoop, built_in_1.BuiltInProcName.WhileLoop, built_in_1.BuiltInProcName.RepeatLoop]);
 /**
  * Checks whether a loop only loops once
  * @param loop        - nodeid of the loop to analyse
@@ -42,7 +43,7 @@ function onlyLoopsOnce(loop, dataflow, controlflow, ast, ctx) {
             resolve: ctx.config.solver.variables,
             ctx: ctx
         }));
-        if (values === undefined || values.elements.length !== 1 || values.elements[0].type !== 'vector' || !(0, r_value_1.isValue)(values.elements[0].elements)) {
+        if (values?.elements.length !== 1 || values.elements[0].type !== 'vector' || !(0, r_value_1.isValue)(values.elements[0].elements)) {
             return undefined;
         }
         if (values.elements[0].elements.length === 1) {
@@ -79,7 +80,7 @@ class CfgSingleIterationLoopDetector extends semantic_cfg_guided_visitor_1.Seman
             resolve: this.config.ctx.config.solver.variables,
             ctx: this.config.ctx
         }));
-        if (values === undefined || values.elements.length !== 1 || values.elements[0].type != 'logical' || !(0, r_value_1.isValue)(values.elements[0].value)) {
+        if (values?.elements.length !== 1 || values.elements[0].type != 'logical' || !(0, r_value_1.isValue)(values.elements[0].value)) {
             return undefined;
         }
         return Boolean(values.elements[0].value);
@@ -119,23 +120,29 @@ class CfgSingleIterationLoopDetector extends semantic_cfg_guided_visitor_1.Seman
             }
         }
     }
-    onDefaultFunctionCall(data) {
+    handleFunctionCall(data) {
         for (const origin of data.call.origin) {
             if (origin === 'builtin:stop' || origin === 'builtin:return' || origin === 'builtin:break') {
                 this.encounteredLoopBreaker = true;
-                this.app(data.call.controlDependencies);
+                this.app(data.call.cds);
                 return;
             }
             else if (origin === 'builtin:stopifnot') {
                 const arg = this.getBoolArgValue(data);
                 if (arg === false) {
                     this.encounteredLoopBreaker = true;
-                    this.app(data.call.controlDependencies);
+                    this.app(data.call.cds);
                     return;
                 }
             }
         }
     }
+    onDefaultFunctionCall(data) {
+        this.handleFunctionCall(data);
+    }
+    onStopIfNotCall(data) {
+        this.handleFunctionCall(data);
+    }
     loopsOnlyOnce() {
         this.startVisitor([]);
         return this.onlyLoopyOnce;

package/dataflow/environments/built-in-config.d.ts

@@ -1,4 +1,5 @@
-import { type BuiltInMappingName, type ConfigOfBuiltInMappingName, BuiltIns } from './built-in';
+import type { BuiltInProcessorMapper, ConfigOfBuiltInMappingName } from './built-in';
+import { BuiltIns } from './built-in';
 import type { Identifier } from './identifier';
 export interface BaseBuiltInDefinition {
     /** The type of the built-in configuration */
@@ -21,7 +22,7 @@ export interface BuiltInConstantDefinition<Value> extends BaseBuiltInDefinition
  * Define a built-in function (like `print` or `c`) and the processor to use.
  * @template BuiltInProcessor - The processor to use for this function
  */
-export interface BuiltInFunctionDefinition<BuiltInProcessor extends BuiltInMappingName> extends BaseBuiltInDefinition {
+export interface BuiltInFunctionDefinition<BuiltInProcessor extends keyof typeof BuiltInProcessorMapper> extends BaseBuiltInDefinition {
     readonly type: 'function';
     readonly processor: BuiltInProcessor;
     readonly config?: ConfigOfBuiltInMappingName<BuiltInProcessor> & {
@@ -40,11 +41,11 @@ export interface BuiltInReplacementDefinition extends BaseBuiltInDefinition {
         readIndices: boolean;
     };
 }
-export type BuiltInDefinition<T extends BuiltInMappingName = BuiltInMappingName> = BuiltInConstantDefinition<unknown> | BuiltInFunctionDefinition<T> | BuiltInReplacementDefinition;
+export type BuiltInDefinition<T extends keyof typeof BuiltInProcessorMapper = keyof typeof BuiltInProcessorMapper> = BuiltInConstantDefinition<unknown> | BuiltInFunctionDefinition<T> | BuiltInReplacementDefinition;
 /**
  * @see DefaultBuiltinConfig
  */
-export type BuiltInDefinitions<Keys extends BuiltInMappingName[] = BuiltInMappingName[]> = [...{
+export type BuiltInDefinitions<Keys extends (keyof typeof BuiltInProcessorMapper)[] = (keyof typeof BuiltInProcessorMapper)[]> = [...{
     [K in keyof Keys]: BuiltInDefinition<Keys[K]>;
 }];
 /**
@@ -56,4 +57,4 @@ export declare function getDefaultBuiltInDefinitions(): BuiltIns;
  * @param definitions - the list of built-in definitions
  * @param loadDefaults - whether to first add the {@link DefaultBuiltinConfig} before the given {@link definitions}
  */
-export declare function getBuiltInDefinitions<Keys extends BuiltInMappingName[]>(definitions: BuiltInDefinitions<Keys>, loadDefaults: boolean | undefined): BuiltIns;
+export declare function getBuiltInDefinitions<Keys extends (keyof typeof BuiltInProcessorMapper)[]>(definitions: BuiltInDefinitions<Keys>, loadDefaults: boolean | undefined): BuiltIns;

package/dataflow/environments/built-in.d.ts

@@ -37,6 +37,8 @@ import type { ReadOnlyFlowrAnalyzerContext } from '../../project/context/flowr-a
 import { processStopIfNot } from '../internal/process/functions/call/built-in/built-in-stop-if-not';
 import { processTryCatch } from '../internal/process/functions/call/built-in/built-in-try-catch';
 import { processRegisterHook } from '../internal/process/functions/call/built-in/built-in-register-hook';
+import { processLocal } from '../internal/process/functions/call/built-in/built-in-local';
+import { processS3Dispatch } from '../internal/process/functions/call/built-in/built-in-s-three-dispatch';
 export type BuiltIn = `built-in:${string}`;
 /**
  * Generate a built-in id for the given name
@@ -56,7 +58,7 @@ export interface BuiltInIdentifierDefinition extends IdentifierReference {
     type: ReferenceType.BuiltInFunction;
     definedAt: BuiltIn;
     processor: BuiltInIdentifierProcessor;
-    config?: ConfigOfBuiltInMappingName<BuiltInMappingName> & {
+    config?: ConfigOfBuiltInMappingName<keyof typeof BuiltInProcessorMapper> & {
         libFn?: boolean;
     };
 }
@@ -65,7 +67,6 @@ export interface BuiltInIdentifierConstant<T = unknown> extends IdentifierRefere
     definedAt: BuiltIn;
     value: T;
 }
-export type UseAsProcessors = 'builtin:default' | 'builtin:return' | 'builtin:stop';
 export interface DefaultBuiltInProcessorConfiguration extends ForceArguments {
     readonly returnsNthArgument?: number | 'last';
     readonly cfg?: ExitPointType;
@@ -77,36 +78,109 @@ export interface DefaultBuiltInProcessorConfiguration extends ForceArguments {
      * Name that should be used for the origin (useful when needing to differentiate between
      * functions like 'return' that use the default builtin processor)
      */
-    readonly useAsProcessor?: UseAsProcessors;
+    readonly useAsProcessor?: BuiltInProcName;
 }
 export type BuiltInEvalHandler = (resolve: VariableResolve, a: RNodeWithParent, ctx: ReadOnlyFlowrAnalyzerContext, env?: REnvironmentInformation, graph?: DataflowGraph, map?: AstIdMap) => Value;
 declare function defaultBuiltInProcessor<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, { returnsNthArgument, useAsProcessor, forceArgs, readAllArguments, cfg, hasUnknownSideEffects, treatAsFnCall }: DefaultBuiltInProcessorConfiguration): DataflowInformation;
+/**
+ * This contains all names of built-in function handlers and origins
+ */
+export declare enum BuiltInProcName {
+    /** for subsetting operations, see {@link processAccess} */
+    Access = "builtin:access",
+    /** for the `*apply` family, see {@link processApply} */
+    Apply = "builtin:apply",
+    /** for assignments like `<-` and `=`, see {@link processAssignment} */
+    Assignment = "builtin:assignment",
+    /** for assignment like functions that may do additional work, see {@link processAssignmentLike} */
+    AssignmentLike = "builtin:assignment-like",
+    /** for `break` calls */
+    Break = "builtin:break",
+    /** the default built-in processor, see {@link defaultBuiltInProcessor} */
+    Default = "builtin:default",
+    /** for `eval` calls, see {@link processEvalCall} */
+    Eval = "builtin:eval",
+    /** for expression lists, see {@link processExpressionList} */
+    ExpressionList = "builtin:expression-list",
+    /** for `for` loops, see {@link processForLoop} */
+    ForLoop = "builtin:for-loop",
+    /** We resolved a function call, similar to {@link BuiltInProcName#Default} */
+    Function = "function",
+    /** for function definitions, see {@link processFunctionDefinition} */
+    FunctionDefinition = "builtin:function-definition",
+    /** for `get` calls, see {@link processGet} */
+    Get = "builtin:get",
+    /** for `if-then-else` constructs, see {@link processIfThenElse} */
+    IfThenElse = "builtin:if-then-else",
+    /** for `library` and `require` calls, see {@link processLibrary} */
+    Library = "builtin:library",
+    /** for `list` calls, see {@link processList} */
+    List = "builtin:list",
+    /** for `local` calls, see {@link processLocal} */
+    Local = "builtin:local",
+    /** for the pipe operators, see {@link processPipe} */
+    Pipe = "builtin:pipe",
+    /** for `quote`, and other substituting calls, see {@link processQuote} */
+    Quote = "builtin:quote",
+    /** for `on.exìt` and other hooks, see {@link processRegisterHook} */
+    RegisterHook = "builtin:register-hook",
+    /** for `repeat` loops, see {@link processRepeatLoop} */
+    RepeatLoop = "builtin:repeat-loop",
+    /** for replacement functions like `names<-`, see {@link processReplacementFunction} */
+    Replacement = "builtin:replacement",
+    /** for `return` calls */
+    Return = "builtin:return",
+    /** for `rm` calls, see {@link processRm} */
+    Rm = "builtin:rm",
+    /** for `UseMethod` calls, see {@link processS3Dispatch} */
+    S3Dispatch = "builtin:s3-dispatch",
+    /** for `source` calls, see {@link processSourceCall} */
+    Source = "builtin:source",
+    /** for special binary operators like `%x%`, see {@link processSpecialBinOp} */
+    SpecialBinOp = "builtin:special-bin-op",
+    /** for `stop` calls */
+    Stop = "builtin:stop",
+    /** for `stopifnot` calls, see {@link processStopIfNot} */
+    StopIfNot = "builtin:stopifnot",
+    /** support for `:=` in subsetting assignments, see {@link processAccess} */
+    TableAssignment = "table:assign",
+    /** for `try` calls, see {@link processTryCatch} */
+    Try = "builtin:try",
+    /** for unnamed directly-linked function calls */
+    Unnamed = "unnamed",
+    /** for vector construction calls, see {@link processVector} */
+    Vector = "builtin:vector",
+    /** for `while` loops, see {@link processWhileLoop} */
+    WhileLoop = "builtin:while-loop"
+}
 export declare const BuiltInProcessorMapper: {
-    readonly 'builtin:access': typeof processAccess;
-    readonly 'builtin:apply': typeof processApply;
-    readonly 'builtin:assignment': typeof processAssignment;
-    readonly 'builtin:assignment-like': typeof processAssignmentLike;
-    readonly 'builtin:default': typeof defaultBuiltInProcessor;
-    readonly 'builtin:eval': typeof processEvalCall;
-    readonly 'builtin:expression-list': typeof processExpressionList;
-    readonly 'builtin:for-loop': typeof processForLoop;
-    readonly 'builtin:function-definition': typeof processFunctionDefinition;
-    readonly 'builtin:get': typeof processGet;
-    readonly 'builtin:if-then-else': typeof processIfThenElse;
-    readonly 'builtin:library': typeof processLibrary;
-    readonly 'builtin:list': typeof processList;
-    readonly 'builtin:pipe': typeof processPipe;
-    readonly 'builtin:quote': typeof processQuote;
-    readonly 'builtin:register-hook': typeof processRegisterHook;
-    readonly 'builtin:repeat-loop': typeof processRepeatLoop;
-    readonly 'builtin:replacement': typeof processReplacementFunction;
-    readonly 'builtin:rm': typeof processRm;
-    readonly 'builtin:source': typeof processSourceCall;
-    readonly 'builtin:special-bin-op': typeof processSpecialBinOp;
-    readonly 'builtin:stopifnot': typeof processStopIfNot;
-    readonly 'builtin:try': typeof processTryCatch;
-    readonly 'builtin:vector': typeof processVector;
-    readonly 'builtin:while-loop': typeof processWhileLoop;
+    readonly "builtin:access": typeof processAccess;
+    readonly "builtin:apply": typeof processApply;
+    readonly "builtin:assignment": typeof processAssignment;
+    readonly "builtin:assignment-like": typeof processAssignmentLike;
+    readonly "builtin:default": typeof defaultBuiltInProcessor;
+    readonly "builtin:eval": typeof processEvalCall;
+    readonly "builtin:expression-list": typeof processExpressionList;
+    readonly "builtin:for-loop": typeof processForLoop;
+    readonly "builtin:function-definition": typeof processFunctionDefinition;
+    readonly "builtin:get": typeof processGet;
+    readonly "builtin:if-then-else": typeof processIfThenElse;
+    readonly "builtin:library": typeof processLibrary;
+    readonly "builtin:list": typeof processList;
+    readonly "builtin:local": typeof processLocal;
+    readonly "builtin:pipe": typeof processPipe;
+    readonly "builtin:quote": typeof processQuote;
+    readonly "builtin:register-hook": typeof processRegisterHook;
+    readonly "builtin:repeat-loop": typeof processRepeatLoop;
+    readonly "builtin:replacement": typeof processReplacementFunction;
+    readonly "builtin:rm": typeof processRm;
+    readonly "builtin:s3-dispatch": typeof processS3Dispatch;
+    readonly "builtin:source": typeof processSourceCall;
+    readonly "builtin:special-bin-op": typeof processSpecialBinOp;
+    readonly "builtin:stopifnot": typeof processStopIfNot;
+    readonly "builtin:try": typeof processTryCatch;
+    readonly "builtin:vector": typeof processVector;
+    readonly "builtin:while-loop": typeof processWhileLoop;
 };
 export declare const BuiltInEvalHandlerMapper: {
     readonly 'built-in:c': typeof resolveAsVector;
@@ -114,24 +188,23 @@ export declare const BuiltInEvalHandlerMapper: {
     readonly 'built-in:+': typeof resolveAsPlus;
     readonly 'built-in:-': typeof resolveAsMinus;
 };
-export type BuiltInMappingName = keyof typeof BuiltInProcessorMapper;
-export type ConfigOfBuiltInMappingName<N extends BuiltInMappingName> = Parameters<typeof BuiltInProcessorMapper[N]>[4];
+export type ConfigOfBuiltInMappingName<N extends keyof typeof BuiltInProcessorMapper> = Parameters<typeof BuiltInProcessorMapper[N]>[4];
 export type BuiltInMemory = Map<Identifier, IdentifierDefinition[]>;
 export declare 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<T>({ names, value, assumePrimitive }: BuiltInConstantDefinition<T>): void;
     /**
-     * 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<BuiltInProcessor extends BuiltInMappingName>({ names, processor, config, assumePrimitive }: BuiltInFunctionDefinition<BuiltInProcessor>): void;
+    registerBuiltInFunctions<BuiltInProcessor extends keyof typeof BuiltInProcessorMapper>({ names, processor, config, assumePrimitive }: BuiltInFunctionDefinition<BuiltInProcessor>): void;
     /**
      * Registers all combinations of replacements
      */
     registerReplacementFunctions({ names, suffixes, assumePrimitive, config }: BuiltInReplacementDefinition): void;
     /**
-     * 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: BuiltInDefinition): void;
     /**

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) {