@eagleoutice/flowr 2.7.6 → 2.8.0

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

@@ -6,6 +6,7 @@ const identify_link_to_last_call_relation_1 = require("../../queries/catalog/cal
 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 unnamed_call_handling_1 = require("../internal/process/functions/call/unnamed-call-handling");
+const hooks_1 = require("../hooks");
 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',
@@ -86,8 +87,9 @@ exports.GgPlotAddons = [
     'ggdraw', 'last_plot'
 ];
 const PlotAddons = exports.GraphicsPlotAddons.concat(exports.GgPlotImplicitAddons, ...exports.PlotFunctionsWithAddParam);
+const RegexConvIn = /[-/\\^$*+?.()|[\]{}]/g;
 function toRegex(n) {
-    return new RegExp(`^(${[...new Set(n)].map(s => s.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')).filter(s => s.length > 0).join('|')})$`);
+    return new RegExp(`^(${Array.from(new Set(n)).map(s => s.replace(RegexConvIn, '\\$&')).filter(s => s.length > 0).join('|')})$`);
 }
 /**
  * Contains the built-in definitions recognized by flowR
@@ -154,7 +156,7 @@ exports.DefaultBuiltinConfig = [
             },
             hasUnknownSideEffects: {
                 type: 'link-to-last-call',
-                callName: toRegex([...exports.PlotCreate, ...PlotAddons]),
+                callName: toRegex(exports.PlotCreate.concat(PlotAddons)),
                 ignoreIf: (source, graph) => {
                     const sourceVertex = graph.getVertex(source);
                     /* map with add = true appends to an existing plot */
@@ -178,10 +180,11 @@ exports.DefaultBuiltinConfig = [
         names: exports.GgPlotAddons,
         processor: 'builtin:default',
         config: {
+            libFn: true,
             forceArgs: 'all',
             hasUnknownSideEffects: {
                 type: 'link-to-last-call',
-                callName: toRegex([...exports.GgPlotCreate, ...exports.GgPlotAddons])
+                callName: toRegex(exports.GgPlotCreate.concat(exports.GgPlotAddons))
             }
         }, assumePrimitive: true
     },
@@ -190,6 +193,7 @@ exports.DefaultBuiltinConfig = [
         names: exports.TinyPlotAddons,
         processor: 'builtin:default',
         config: {
+            libFn: true,
             forceArgs: 'all',
             hasUnknownSideEffects: {
                 type: 'link-to-last-call',
@@ -202,17 +206,21 @@ exports.DefaultBuiltinConfig = [
         names: ['image_write', 'image_capture', 'dev.capture', 'dev.off'],
         processor: 'builtin:default',
         config: {
+            libFn: true,
             forceArgs: 'all',
             hasUnknownSideEffects: {
                 type: 'link-to-last-call',
-                callName: toRegex([...GraphicDeviceOpen, ...exports.PlotCreate, ...PlotAddons, ...exports.GgPlotAddons, ...exports.TinyPlotAddons])
+                callName: toRegex(GraphicDeviceOpen.concat(exports.PlotCreate, PlotAddons, exports.GgPlotAddons, exports.TinyPlotAddons))
             }
         }, 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: ['.Call', '.External', '.C', '.Fortran'], processor: 'builtin:default', config: { hasUnknownSideEffects: true, forceArgs: [true],
+    { type: 'function',
+        names: ['.Call', '.External', '.C', '.Fortran'],
+        processor: 'builtin:default',
+        config: { hasUnknownSideEffects: true, forceArgs: [true],
             treatAsFnCall: {
                 '.Call': ['.NAME'],
                 '.External': ['.NAME'],
@@ -223,9 +231,11 @@ exports.DefaultBuiltinConfig = [
     { 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: false },
-    { type: 'function', names: ['stop'], processor: 'builtin:default', config: { useAsProcessor: 'builtin:stop' }, assumePrimitive: false },
-    { type: 'function', names: ['stopifnot'], processor: 'builtin:default', config: { useAsProcessor: 'builtin:stopifnot' }, assumePrimitive: false },
+    { type: 'function', names: ['return'], processor: 'builtin:default', config: { returnsNthArgument: 0, cfg: 1 /* ExitPointType.Return */, useAsProcessor: 'builtin:return' }, assumePrimitive: true },
+    { type: 'function', names: ['stop', 'abort'], processor: 'builtin:default', config: { useAsProcessor: 'builtin: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 },
@@ -237,7 +247,8 @@ exports.DefaultBuiltinConfig = [
     { 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'], processor: 'builtin:assignment', config: { targetVariable: true }, assumePrimitive: true },
+    { type: 'function', names: ['assign', 'setGeneric', 'setValidity'], processor: 'builtin:assignment', config: { targetVariable: 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 },
@@ -251,9 +262,10 @@ exports.DefaultBuiltinConfig = [
     { 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' }, assumePrimitive: false },
-    { type: 'function', names: ['ddply'], processor: 'builtin:apply', config: { unquoteFunction: true, indexOfFunction: 2, nameOfFunctionArgument: '.fun' }, assumePrimitive: false },
+    { 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' },
     {
@@ -270,11 +282,9 @@ exports.DefaultBuiltinConfig = [
     {
         type: 'function',
         names: [
-            'on.exit', 'sys.on.exit', 'par', 'tpar', 'sink', 'tinytheme', 'theme_set',
+            'sys.on.exit', 'par', 'tpar', 'sink',
             /* library and require is handled above */
             'requireNamespace', 'loadNamespace', 'attachNamespace', 'asNamespace',
-            /* 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',
             /* weird env attachments */
             'attach', 'unname', 'data',
             /* file creation/removal */
@@ -284,6 +294,31 @@ exports.DefaultBuiltinConfig = [
         config: { hasUnknownSideEffects: true },
         assumePrimitive: false
     },
+    {
+        type: 'function',
+        names: [
+            'tinytheme', 'theme_set',
+            /* 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',
+        config: { hasUnknownSideEffects: true, libFn: true },
+        assumePrimitive: false
+    },
+    {
+        type: 'function',
+        names: ['on.exit'],
+        processor: 'builtin:register-hook',
+        config: {
+            hook: hooks_1.KnownHooks.OnFnExit,
+            args: {
+                expr: { idx: 0, name: 'expr' },
+                add: { idx: 1, name: 'add', default: false },
+                after: { idx: 2, name: 'after', default: true },
+            }
+        },
+        assumePrimitive: true
+    },
     /* they are all mapped to `<-` but we separate super assignments */
     {
         type: 'replacement',
@@ -303,7 +338,7 @@ exports.DefaultBuiltinConfig = [
     }
 ];
 /**
- *
+ * Expensive and naive lookup of the default processor for a built-in function name
  */
 function getDefaultProcessor(name) {
     if (name.startsWith(unnamed_call_handling_1.UnnamedFunctionCallPrefix)) {

package/dataflow/environments/environment.js

@@ -130,8 +130,9 @@ class Environment {
                 // we need to make a copy to avoid side effects for old reference in other environments
                 const updatedOld = old?.slice() ?? [];
                 for (const v of values) {
-                    const index = updatedOld.findIndex(o => o.nodeId === v.nodeId && o.definedAt === v.definedAt);
-                    if (index >= 0) {
+                    const { nodeId, definedAt } = v;
+                    const index = updatedOld.find(o => o.nodeId === nodeId && o.definedAt === definedAt);
+                    if (index) {
                         continue;
                     }
                     if (applyCds === undefined) {

package/dataflow/environments/identifier.d.ts

@@ -74,7 +74,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;
+    controlDependencies?: ControlDependency[] | undefined;
 }
 /**
  * The definition of an {@link Identifier|identifier} within the {@link DataflowGraph|graph}.
@@ -94,6 +94,10 @@ export interface InGraphIdentifierDefinition extends IdentifierReference {
      * (the arrow operator for e.g. `x <- 3`, or `assign` call in `assign("x", 3)`)
      */
     readonly definedAt: NodeId;
+    /**
+     * For value tracking, this contains all nodeIds of constant values that may be made available to this identifier
+     * For example, in `x <- 3; y <- x`, the definition of `y` will have the value `3` in its value set
+     */
     readonly value?: NodeId[];
     /**
      * this attribute links a definition to indices (pointer links) it may be affected by or related to

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

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

@@ -4,6 +4,19 @@ exports.makeReferenceMaybe = makeReferenceMaybe;
 exports.makeAllMaybe = makeAllMaybe;
 const identifier_1 = require("./identifier");
 const resolve_by_name_1 = require("./resolve-by-name");
+function appToCdsUnique(target, toAdd) {
+    if (toAdd) {
+        target.push(...toAdd.filter(c => !target.find(tc => tc.id === c.id && tc.when === c.when)));
+    }
+}
+function concatCdsUnique(target, toAdd) {
+    if (toAdd) {
+        return target.concat(toAdd.filter(c => !target.find(tc => tc.id === c.id && tc.when === c.when)));
+    }
+    else {
+        return target;
+    }
+}
 /**
  * Marks the reference as maybe (i.e., as controlled by a set of {@link IdentifierReference#controlDependencies|control dependencies}).
  */
@@ -13,34 +26,30 @@ function makeReferenceMaybe(ref, graph, environments, includeDefs, defaultCd = u
         for (const definition of definitions ?? []) {
             if (definition.type !== identifier_1.ReferenceType.BuiltInFunction && definition.type !== identifier_1.ReferenceType.BuiltInConstant) {
                 if (definition.controlDependencies) {
-                    if (defaultCd && !definition.controlDependencies.find(c => c.id === defaultCd.id && c.when === defaultCd.when)) {
-                        definition.controlDependencies.push(defaultCd);
-                    }
+                    appToCdsUnique(definition.controlDependencies, defaultCd);
                 }
                 else {
-                    definition.controlDependencies = defaultCd ? [defaultCd] : [];
+                    definition.controlDependencies = defaultCd ? Array.from(defaultCd) : [];
                 }
             }
         }
     }
     const node = graph.getVertex(ref.nodeId, true);
     if (node) {
-        if (node.cds) {
-            if (defaultCd && !node.cds.find(c => c.id === defaultCd.id && c.when === defaultCd.when)) {
-                node.cds.push(defaultCd);
-            }
+        if (node.controlDependencies) {
+            appToCdsUnique(node.controlDependencies, defaultCd);
         }
         else {
-            node.cds = defaultCd ? [defaultCd] : [];
+            node.controlDependencies = defaultCd ? Array.from(defaultCd) : [];
         }
     }
     if (ref.controlDependencies) {
-        if (defaultCd && !ref.controlDependencies.find(c => c.id === defaultCd.id && c.when === defaultCd.when)) {
-            return { ...ref, controlDependencies: (ref.controlDependencies ?? []).concat(defaultCd ? [defaultCd] : []) };
+        if (defaultCd) {
+            return { ...ref, controlDependencies: concatCdsUnique(ref.controlDependencies, defaultCd) };
         }
     }
     else {
-        return { ...ref, controlDependencies: ref.controlDependencies ?? (defaultCd ? [defaultCd] : []) };
+        return { ...ref, controlDependencies: defaultCd ? Array.from(defaultCd) : [] };
     }
     return ref;
 }
@@ -48,7 +57,7 @@ function makeReferenceMaybe(ref, graph, environments, includeDefs, defaultCd = u
  * Marks all references as maybe (i.e., as controlled by a set of {@link IdentifierReference#controlDependencies|control dependencies}).
  * @see {@link makeReferenceMaybe}
  */
-function makeAllMaybe(references, graph, environments, includeDefs, defaultCd = undefined) {
-    return references?.map(ref => makeReferenceMaybe(ref, graph, environments, includeDefs, defaultCd)) ?? [];
+function makeAllMaybe(references, graph, environments, includeDefs, applyCds = undefined) {
+    return references?.map(ref => makeReferenceMaybe(ref, graph, environments, includeDefs, applyCds)) ?? [];
 }
 //# sourceMappingURL=reference-to-maybe.js.map

package/dataflow/environments/resolve-by-name.d.ts

@@ -10,12 +10,16 @@ import { type Identifier, type IdentifierDefinition, ReferenceType } from './ide
  * @returns A list of possible identifier definitions (one if the definition location is exactly and always known), or `undefined`
  *          if the identifier is undefined in the current scope/with the current environment information.
  */
-export declare function resolveByName(name: Identifier, environment: REnvironmentInformation, target: ReferenceType): IdentifierDefinition[] | undefined;
+export declare function resolveByName(name: Identifier, environment: REnvironmentInformation, target: ReferenceType): readonly IdentifierDefinition[] | undefined;
 /**
  * The more performant version of {@link resolveByName} when the target type is unknown.
  */
 export declare function resolveByNameAnyType(name: Identifier, environment: REnvironmentInformation): IdentifierDefinition[] | undefined;
 /**
- *
+ * Checks whether the given identifier name resolves to a built-in constant with the given value.
+ * @param name               - The name of the identifier to resolve
+ * @param environment        - The current environment used for name resolution
+ * @param wantedValue        - The built-in constant value to check for
+ * @returns Whether the identifier always, never, or maybe resolves to the given built-in constant value
  */
 export declare function resolvesToBuiltInConstant(name: Identifier | undefined, environment: REnvironmentInformation, wantedValue: unknown): Ternary;

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

@@ -107,7 +107,11 @@ function resolveByNameAnyType(name, environment) {
     return ret;
 }
 /**
- *
+ * Checks whether the given identifier name resolves to a built-in constant with the given value.
+ * @param name               - The name of the identifier to resolve
+ * @param environment        - The current environment used for name resolution
+ * @param wantedValue        - The built-in constant value to check for
+ * @returns Whether the identifier always, never, or maybe resolves to the given built-in constant value
  */
 function resolvesToBuiltInConstant(name, environment, wantedValue) {
     if (name === undefined) {

package/dataflow/environments/scoping.js

@@ -20,10 +20,8 @@ function pushLocalEnvironment({ level, current }) {
  */
 function popLocalEnvironment({ current, level }) {
     (0, assert_1.guard)(level > 0, 'cannot remove the global/root environment');
-    const parent = current.parent;
-    (0, assert_1.guard)(parent !== undefined, 'level is wrong, parent is undefined even though level suggested depth > 0 (starts with 0)');
     return {
-        current: parent,
+        current: current.parent,
         level: level - 1
     };
 }

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

@@ -126,6 +126,10 @@ function resolveIdToValue(id, { environment, graph, idMap, full = true, resolve,
     }
     switch (node.type) {
         case type_1.RType.Argument:
+            if (node.value) {
+                return resolveIdToValue(node.value.info.id, { environment, graph, idMap, full, resolve: variableResolve, ctx });
+            }
+        // eslint-disable-next-line no-fallthrough
         case type_1.RType.Symbol:
             if (environment) {
                 return full ? trackAliasInEnvironments(variableResolve, node.lexeme, environment, ctx, graph, idMap) : r_value_1.Top;
@@ -278,7 +282,7 @@ function trackAliasesInGraph(id, graph, ctx, idMap) {
             continue;
         }
         const [vertex, outgoingEdges] = res;
-        const cds = vertex.cds;
+        const cds = vertex.controlDependencies;
         for (const cd of cds ?? []) {
             const target = graph.idMap?.get(cd.id);
             if (target === undefined) {

package/dataflow/extractor.js

@@ -52,7 +52,7 @@ exports.processors = {
             info: info,
             content: groupStart?.content ?? '{',
             lexeme: groupStart?.lexeme ?? '{',
-            location: location ?? (0, range_1.rangeFrom)(-1, -1, -1, -1),
+            location: location ?? (0, range_1.invalidRange)(),
             namespace: groupStart?.content ? undefined : 'base'
         }, (0, make_argument_1.wrapArgumentsUnnamed)(children, d.completeAst.idMap), info.id, d);
     }
@@ -125,8 +125,8 @@ function produceDataFlowGraph(parser, completeAst, ctx) {
     }
     // finally, resolve linkages
     (0, built_in_function_definition_1.updateNestedFunctionCalls)(df.graph, df.environment);
-    const cfgQuick = resolveLinkToSideEffects(completeAst, df.graph);
+    df.cfgQuick = resolveLinkToSideEffects(completeAst, df.graph);
     // performance optimization: return cfgQuick as part of the result to avoid recomputation
-    return { ...df, cfgQuick };
+    return df;
 }
 //# sourceMappingURL=extractor.js.map

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

@@ -0,0 +1,13 @@
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { CallGraph } from '../graph/call-graph';
+import type { ControlDependency } from '../info';
+export interface ExceptionPoint {
+    id: NodeId;
+    cds?: readonly ControlDependency[] | undefined;
+}
+/**
+ * Collect exception sources of a function in the call graph.
+ * This returns the `NodeId`s of functions that may throw exceptions when called by the given function.
+ * Please be aware, that these are restricted to functions known by flowR.
+ */
+export declare function calculateExceptionsOfFunction(id: NodeId, graph: CallGraph): ExceptionPoint[];

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateExceptionsOfFunction = calculateExceptionsOfFunction;
+const vertex_1 = require("../graph/vertex");
+const built_in_1 = require("../environments/built-in");
+const CatchHandlers = new Set(['builtin:try']);
+/**
+ * Collect exception sources of a function in the call graph.
+ * This returns the `NodeId`s of functions that may throw exceptions when called by the given function.
+ * Please be aware, that these are restricted to functions known by flowR.
+ */
+function calculateExceptionsOfFunction(id, graph) {
+    const collectedExceptions = [];
+    const visited = new Set();
+    const toVisit = [id];
+    while (toVisit.length > 0) {
+        const currentId = toVisit.pop();
+        if (visited.has(currentId)) {
+            continue;
+        }
+        visited.add(currentId);
+        const vtx = graph.getVertex(currentId);
+        if (!vtx) {
+            continue;
+        }
+        if ((0, built_in_1.isBuiltIn)(currentId)) {
+            continue;
+        }
+        if (vtx.tag === vertex_1.VertexType.FunctionDefinition) {
+            for (const e of vtx.exitPoints.filter(e => e.type === 4 /* ExitPointType.Error */)) {
+                if (!collectedExceptions.find(x => x.id === e.nodeId)) {
+                    collectedExceptions.push({ id: e.nodeId, cds: e.controlDependencies });
+                }
+            }
+        }
+        else if (vtx.tag === vertex_1.VertexType.FunctionCall && vtx.origin !== 'unnamed' && vtx.origin.some(c => CatchHandlers.has(c))) {
+            // skip the try-catch handlers as they catch all exceptions within their body
+            continue;
+        }
+        const outEdges = graph.outgoingEdges(currentId) ?? [];
+        for (const [out] of outEdges) {
+            toVisit.push(out);
+        }
+    }
+    return collectedExceptions;
+}
+//# sourceMappingURL=exceptions-of-function.js.map

package/dataflow/fn/higher-order-function.d.ts

@@ -7,4 +7,4 @@ import type { ReadOnlyFlowrAnalyzerContext } from '../../project/context/flowr-a
  * If the return is an identity, e.g., `function(x) x`, this is not considered higher-order,
  * if no function is passed as an argument.
  */
-export declare function isHigherOrder(id: NodeId, graph: DataflowGraph, ctx: ReadOnlyFlowrAnalyzerContext): boolean;
+export declare function isFunctionHigherOrder(id: NodeId, graph: DataflowGraph, ctx: ReadOnlyFlowrAnalyzerContext): boolean;

package/dataflow/fn/higher-order-function.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isHigherOrder = isHigherOrder;
+exports.isFunctionHigherOrder = isFunctionHigherOrder;
 const vertex_1 = require("../graph/vertex");
 const assert_1 = require("../../util/assert");
 const edge_1 = require("../graph/edge");
@@ -9,7 +9,7 @@ const config_1 = require("../../config");
 const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const general_1 = require("../eval/values/general");
 function isAnyReturnAFunction(def, graph) {
-    const workingQueue = def.exitPoints.map(d => graph.getVertex(d, true)).filter(assert_1.isNotUndefined);
+    const workingQueue = def.exitPoints.map(d => graph.getVertex(d.nodeId, true)).filter(assert_1.isNotUndefined);
     const seen = new Set();
     while (workingQueue.length > 0) {
         const current = workingQueue.pop();
@@ -60,7 +60,7 @@ function inspectCallSitesArgumentsFns(def, graph, ctx) {
  * If the return is an identity, e.g., `function(x) x`, this is not considered higher-order,
  * if no function is passed as an argument.
  */
-function isHigherOrder(id, graph, ctx) {
+function isFunctionHigherOrder(id, graph, ctx) {
     const vert = graph.getVertex(id);
     if (!vert || !(0, vertex_1.isFunctionDefinitionVertex)(vert)) {
         return false;

package/dataflow/fn/recursive-function.d.ts

@@ -0,0 +1,6 @@
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { CallGraph } from '../graph/call-graph';
+/**
+ * Determines whether the function with the given ID is recursive.
+ */
+export declare function isFunctionRecursive(id: NodeId, graph: CallGraph): boolean;

package/dataflow/fn/recursive-function.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFunctionRecursive = isFunctionRecursive;
+const vertex_1 = require("../graph/vertex");
+/**
+ * Determines whether the function with the given ID is recursive.
+ */
+function isFunctionRecursive(id, graph) {
+    const vert = graph.getVertex(id);
+    if (!vert || !(0, vertex_1.isFunctionDefinitionVertex)(vert)) {
+        return false;
+    }
+    const seen = new Set();
+    const toVisit = [id];
+    let gotStart = 0;
+    while (toVisit.length > 0) {
+        const currentId = toVisit.pop();
+        if (currentId === id && gotStart++ > 0) {
+            return true;
+        }
+        if (seen.has(currentId)) {
+            continue;
+        }
+        seen.add(currentId);
+        const out = graph.outgoingEdges(currentId)?.keys() ?? [];
+        for (const nextId of out) {
+            toVisit.push(nextId);
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=recursive-function.js.map

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

@@ -0,0 +1,10 @@
+import { DataflowGraph } from './graph';
+import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexFunctionDefinition } from './vertex';
+/**
+ * A call graph is a dataflow graph where all vertices are function calls.
+ */
+export type CallGraph = DataflowGraph<Required<DataflowGraphVertexFunctionCall | DataflowGraphVertexFunctionDefinition>>;
+/**
+ * Computes the call graph from the given dataflow graph.
+ */
+export declare function computeCallGraph(graph: DataflowGraph): CallGraph;