@eagleoutice/flowr 2.2.12 → 2.2.13

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

@@ -1,20 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultBuiltinConfig = void 0;
+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 unnamed_call_handling_1 = require("../internal/process/functions/call/unnamed-call-handling");
 const GgPlotCreate = [
-    'ggplot', 'ggplotly'
+    'ggplot', 'ggplotly', 'ggMarginal', 'ggcorrplot', 'ggseasonplot', 'ggdendrogram', 'qmap', 'qplot', 'quickplot', 'autoplot', 'grid.arrange',
+    'fviz_pca_biplot', 'fviz_pca', 'fviz_pca_ind', 'fviz_pca_var', 'fviz_screeplot', 'fviz_mca_biplot', 'fviz_mca', 'fviz_mca_ind', 'fviz_mca_var', 'fviz_cluster', 'fviz_dend',
+    'ggsurvplot',
 ];
 const TinyPlotCrate = [
     'tinyplot', 'plt'
 ];
 const PlotCreate = [
     'plot', 'plot.new', 'xspline', 'map', 'curve', 'image', 'boxplot', 'dotchart', 'sunflowerplot', 'barplot', 'matplot', 'hist', 'stem',
-    'density', 'smoothScatter', 'contour', 'persp', 'XYPlot', 'xyplot', 'stripplot', 'bwplot', 'dotPlot', 'dotplot', 'histPlot', 'densityPlot', 'qPlot', 'qqPlot', 'boxPlot',
-    'bxp', 'assocplot', 'mosaicplot', 'stripchart', 'fourfoldplot', 'mosaicplot', 'plot.xy', 'plot.formula', 'plot.default', 'plot.design', 'stars',
-    'spineplot', 'Plotranges', 'regressogram', 'bootcurve', 'meanplot', 'vioplot', 'pairs', 'copolot', 'histogram', 'splom', 'leaflet', 'tm_shape', 'plot_ly',
+    'density', 'smoothScatter', 'contour', 'persp', 'XYPlot', 'xyplot', 'stripplot', 'bwplot', 'dotPlot', 'dotplot', 'histPlot', 'densityPlot', 'qPlot', 'qqplot', 'qqPlot', 'boxPlot',
+    'bxp', 'assocplot', 'mosaicplot', 'stripchart', 'fourfoldplot', 'plot.xy', 'plot.formula', 'plot.default', 'plot.design', 'stars', 'cotabplot', 'pheatmap',
+    'spineplot', 'Plotranges', 'regressogram', 'bootcurve', 'meanplot', 'vioplot', 'pairs', 'copolot', 'histogram', 'splom', 'leaflet', 'tm_shape', 'plot_ly', 'plotProfLik', 'plotSimulatedResiduals', 'plotmeans',
+    'overplot', 'residplot', 'heatmap.2', 'lmplot2', 'sinkplot', 'textplot', 'boxplot2', 'profLikCI',
     ...TinyPlotCrate,
     ...GgPlotCreate
 ];
@@ -25,9 +30,58 @@ const GraphicDeviceOpen = [
 const TinyPlotAddons = [
     'tinyplot_add', 'plt_add'
 ];
+const GgPlotImplicitAddons = [
+    'geom_count', 'geom_bin_2d', 'geom_spoke', 'geom_tile', 'geom_rect',
+    'geom_function', 'geom_crossbar', 'geom_density2d', 'geom_abline', 'geom_errorbar', 'geom_errorbarh',
+    'geom_jitter', 'geom_line', 'geom_density', 'geom_quantile', 'geom_qq', 'geom_qq_line', 'geom_segment', 'geom_label', 'geom_density_2d',
+    'geom_violin', 'geom_contour', 'geom_boxplot', 'geom_col', 'geom_blank', 'geom_histogram', 'geom_hline', 'geom_area', 'geom_sf_text', 'geom_smooth', 'geom_text',
+    'geom_density2d_filled', 'geom_ribbon', 'geom_sf', 'geom_dotplot', 'geom_freqpoly', 'geom_step', 'geom_map', 'geom_bin2d', 'geom_rug', 'geom_raster', 'geom_pointrange', 'geom_point',
+    'geom_hex', 'geom_contour_filled', 'geom_bar', 'geom_vline', 'geom_linerange', 'geom_curve', 'geom_path', 'geom_polygon', 'geom_sf_label', 'geom_density_2d_filled', 'geom_dumbbell',
+    'geom_encircle', 'stat_count', 'stat_density', 'stat_bin_hex', 'stat_bin_2d', 'stat_summary_bin', 'stat_identity', 'stat_qq', 'stat_binhex', 'stat_boxplot', 'stat_function',
+    'stat_align', 'stat_contour_filled', 'stat_summary_2d', 'stat_qq_line', 'stat_contour', 'stat_ydensity', 'stat_summary_hex', 'stat_summary2d', 'stat_sf_coordinates',
+    'stat_density_2d_filled', 'stat_smooth', 'stat_density2d', 'stat_ecdf', 'stat_sf', 'stat_quantile', 'stat_unique', 'stat_density_2d', 'stat_ellipse', 'stat_summary',
+    'stat_density2d_filled', 'stat_bin', 'stat_sum', 'stat_spoke', 'stat_bin2d',
+    'labs', 'theme_void', 'theme_test', 'theme_minimal', 'theme_light', 'theme', 'theme_get', 'theme_gray', 'theme_dark', 'theme_classic', 'theme_linedraw', 'theme_update',
+    'theme_replace', 'theme_grey', 'theme_bw', 'theme_tufte', 'theme_survminer', 'facet_null', 'facet_grid', 'facet_wrap', 'xlab', 'xlim', 'ylab', 'ylim',
+    'scale_linewidth_ordinal', 'scale_fill_steps', 'scale_color_gradient2', 'scale_size_manual', 'scale_colour_discrete', 'scale_color_identity',
+    'scale_fill_fermenter', 'scale_alpha_manual', 'scale_fill_gradient', 'scale_size_date', 'scale_fill_viridis_b', 'scale_x_time', 'scale_linetype_manual',
+    'scale_alpha_binned', 'scale_color_grey', 'scale_colour_gradient', 'scale_linewidth_date', 'scale_color_steps2', 'scale_color_viridis_b', 'scale_size_binned',
+    'scale_colour_gradientn', 'scale_linewidth_manual', 'scale_fill_viridis_c', 'scale_fill_manual', 'scale_color_viridis_c', 'scale_fill_discrete', 'scale_size_discrete',
+    'scale_fill_binned', 'scale_fill_viridis_d', 'scale_colour_fermenter', 'scale_color_viridis_d', 'scale_x_datetime', 'scale_size_identity', 'scale_linewidth_identity',
+    'scale_shape_ordinal', 'scale_linewidth_discrete', 'scale_fill_ordinal', 'scale_y_time', 'scale_color_ordinal', 'scale_size_ordinal', 'scale_colour_distiller',
+    'scale_linewidth_datetime', 'scale_alpha_identity', 'scale_color_steps', 'scale_alpha_discrete', 'scale_fill_date', 'scale_x_reverse', 'scale_fill_gradientn', 'scale_size_datetime',
+    'scale_y_continuous', 'scale_colour_steps', 'scale_color_distiller', 'scale_colour_ordinal', 'scale_y_datetime', 'scale_linetype_discrete', 'scale_colour_viridis_b',
+    'scale_alpha_datetime', 'scale_continuous_identity', 'scale_fill_brewer', 'scale_shape_identity', 'scale_color_discrete', 'scale_colour_viridis_c', 'scale_linetype_identity',
+    'scale_colour_hue', 'scale_linewidth_binned', 'scale_color_hue', 'scale_shape_continuous', 'scale_colour_viridis_d', 'scale_size_continuous', 'scale_color_manual', 'scale_alpha_date',
+    'scale_y_sqrt', 'scale_shape_binned', 'scale_size', 'scale_color_fermenter', 'scale_color_stepsn', 'scale_size_area', 'scale_y_binned', 'scale_y_discrete', 'scale_alpha_continuous',
+    'scale_fill_continuous', 'scale_linetype_continuous', 'scale_colour_steps2', 'scale_colour_datetime', 'scale_colour_grey', 'scale_x_log10', 'scale_x_discrete', 'scale_color_continuous',
+    'scale_type', 'scale_y_reverse', 'scale_colour_gradient2', 'scale_color_datetime', 'scale_color_date', 'scale_x_continuous', 'scale_colour_manual', 'scale_fill_gradient2',
+    'scale_fill_grey', 'scale_colour_stepsn', 'scale_colour_binned', 'scale_color_binned', 'scale_color_gradientn', 'scale_colour_date', 'scale_fill_distiller', 'scale_color_gradient',
+    'scale_linewidth_continuous', 'scale_shape', 'scale_fill_hue', 'scale_linetype', 'scale_colour_identity', 'scale_discrete_manual', 'scale_fill_identity', 'scale_y_log10',
+    'scale_linetype_binned', 'scale_size_binned_area', 'scale_y_date', 'scale_x_binned', 'scale_shape_discrete', 'scale_colour_brewer', 'scale_x_date', 'scale_discrete_identity',
+    'scale_alpha', 'scale_fill_steps2', 'scale_color_brewer', 'scale_fill_datetime', 'scale_shape_manual', 'scale_colour_continuous', 'scale_alpha_ordinal', 'scale_linewidth', 'scale_x_sqrt',
+    'scale_fill_stepsn', 'scale_radius', 'rotateTextX', 'removeGridX', 'removeGridY', 'removeGrid',
+    'coord_trans', 'coord_sf', 'coord_cartesian', 'coord_fixed', 'coord_flip', 'coord_quickmap', 'coord_equal', 'coord_map', 'coord_polar', 'coord_munch', 'coord_radial',
+    'annotate', 'annotation_custom', 'annotation_raster', 'annotation_map', 'annotation_logticks', 'borders', 'ggtitle', 'expansion', 'expand_limits', 'expand_scale', 'guides',
+    'wrap_by',
+    'theme_solid', 'theme_hc', 'theme_excel_new', 'theme_few', 'theme_clean', 'theme_wsj', 'theme_calc', 'theme_par', 'theme_tufte', 'theme_igray', 'theme_solarized_2', 'theme_excel',
+    'theme_economist', 'theme_stata', 'theme_map', 'theme_fivethirtyeight', 'theme_economist_white', 'theme_base', 'theme_foundation', 'theme_gdocs', 'theme_pander', 'theme_solarized',
+    'scale_shape_tableau', 'scale_fill_pander', 'scale_shape_few', 'scale_colour_excel_new', 'scale_colour_hc', 'scale_fill_ptol', 'scale_fill_gradient2_tableau', 'scale_shape_calc', 'scale_fill_stata',
+    'scale_colour_tableau', 'scale_colour_colorblind', 'scale_color_stata', 'scale_colour_economist', 'scale_fill_calc', 'scale_fill_gradient_tableau', 'scale_shape_cleveland', 'scale_color_pander',
+    'scale_colour_pander', 'scale_color_fivethirtyeight', 'scale_color_wsj', 'scale_shape_stata', 'scale_colour_gdocs', 'scale_color_continuous_tableau', 'scale_fill_excel', 'scale_color_few', 'scale_linetype_stata',
+    'scale_shape_tremmel', 'scale_color_tableau', 'scale_color_colorblind', 'scale_fill_colorblind', 'scale_colour_stata', 'scale_fill_wsj', 'scale_colour_calc', 'scale_colour_fivethirtyeight', 'scale_fill_hc',
+    'scale_shape_circlefill', 'scale_fill_excel_new', 'scale_color_solarized', 'scale_color_excel', 'scale_colour_excel', 'scale_fill_tableau', 'scale_colour_ptol', 'scale_colour_canva', 'scale_color_gradient2_tableau',
+    'scale_colour_solarized', 'scale_colour_gradient2_tableau', 'scale_fill_canva', 'scale_color_ptol', 'scale_color_excel_new', 'scale_color_economist', 'scale_fill_economist', 'scale_fill_fivethirtyeight',
+    'scale_colour_gradient_tableau', 'scale_colour_few', 'scale_color_calc', 'scale_fill_few', 'scale_fill_gdocs', 'scale_color_hc', 'scale_color_gdocs', 'scale_color_canva', 'scale_color_gradient_tableau',
+    'scale_fill_solarized', 'scale_fill_continuous_tableau', 'scale_colour_wsj', 'gradient_color', 'ggsurvplot_add_all'
+];
+const PlotFunctionsWithAddParam = new Set([
+    'map', 'matplot', 'barplot', 'boxplot', 'curve', 'image', 'plotCI', 'bandplot', 'barplot2', 'bubbleplot'
+]);
 const PlotAddons = [
-    'points', 'abline', 'map', 'mtext', 'lines', 'text', 'legend', 'title', 'axis', 'polygon', 'polypath', 'pie', 'rect', 'segments', 'arrows', 'symbols',
-    'tiplabels', 'rug', 'grid', 'box', 'clip'
+    'points', 'abline', 'mtext', 'lines', 'text', 'legend', 'title', 'axis', 'polygon', 'polypath', 'pie', 'rect', 'segments', 'arrows', 'symbols',
+    'qqline', 'qqnorm', 'rasterImage',
+    'tiplabels', 'rug', 'grid', 'box', 'clip', 'matpoints', 'matlines', ...GgPlotImplicitAddons, ...PlotFunctionsWithAddParam
 ];
 const GgPlotAddons = [
     'ggdraw', 'last_plot'
@@ -83,8 +137,8 @@ exports.DefaultBuiltinConfig = [
                 type: 'link-to-last-call',
                 ignoreIf: (source, graph) => {
                     /* map with add = true appends to an existing plot */
-                    return (source.name === 'map' && (0, identify_link_to_last_call_relation_1.getValueOfArgument)(graph, source, {
-                        index: 11,
+                    return (PlotFunctionsWithAddParam.has(source.name) && (0, identify_link_to_last_call_relation_1.getValueOfArgument)(graph, source, {
+                        index: -1,
                         name: 'add'
                     }, [type_1.RType.Logical])?.content === true);
                 },
@@ -95,14 +149,17 @@ exports.DefaultBuiltinConfig = [
     { type: 'function', names: PlotAddons,
         processor: 'builtin:default', config: {
             forceArgs: 'all',
+            treatAsFnCall: {
+                'facet_grid': ['labeller']
+            },
             hasUnknownSideEffects: {
                 type: 'link-to-last-call',
-                callName: toRegex(PlotCreate),
+                callName: toRegex([...PlotCreate, ...PlotAddons]),
                 ignoreIf: (source, graph) => {
                     const sourceVertex = graph.getVertex(source);
                     /* map with add = true appends to an existing plot */
-                    return (sourceVertex?.name === 'map' && (0, identify_link_to_last_call_relation_1.getValueOfArgument)(graph, sourceVertex, {
-                        index: 11,
+                    return (PlotFunctionsWithAddParam.has(sourceVertex.name ?? '') && (0, identify_link_to_last_call_relation_1.getValueOfArgument)(graph, sourceVertex, {
+                        index: -1,
                         name: 'add'
                     }, [type_1.RType.Logical])?.content !== true);
                 },
@@ -124,7 +181,7 @@ exports.DefaultBuiltinConfig = [
             forceArgs: 'all',
             hasUnknownSideEffects: {
                 type: 'link-to-last-call',
-                callName: toRegex(GgPlotCreate)
+                callName: toRegex([...GgPlotCreate, ...GgPlotAddons])
             }
         }, assumePrimitive: true
     },
@@ -136,7 +193,7 @@ exports.DefaultBuiltinConfig = [
             forceArgs: 'all',
             hasUnknownSideEffects: {
                 type: 'link-to-last-call',
-                callName: toRegex(TinyPlotCrate)
+                callName: toRegex([...TinyPlotCrate, ...TinyPlotAddons])
             }
         }, assumePrimitive: true
     },
@@ -185,6 +242,8 @@ exports.DefaultBuiltinConfig = [
     { 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: ['.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: ['list'], processor: 'builtin:list', config: {}, assumePrimitive: true },
     { type: 'function', names: ['c'], processor: 'builtin:vector', config: {}, assumePrimitive: true },
     {
@@ -201,7 +260,7 @@ exports.DefaultBuiltinConfig = [
     {
         type: 'function',
         names: [
-            'on.exit', 'sys.on.exit', 'par', 'tpar', 'sink', 'tinytheme',
+            'on.exit', 'sys.on.exit', 'par', 'tpar', 'sink', 'tinytheme', 'theme_set',
             /* library and require is handled above */
             'requireNamespace', 'loadNamespace', 'attachNamespace', 'asNamespace',
             /* downloader and installer functions (R, devtools, BiocManager) */
@@ -233,4 +292,12 @@ exports.DefaultBuiltinConfig = [
         }
     }
 ];
+function getDefaultProcessor(name) {
+    if (name.startsWith(unnamed_call_handling_1.UnnamedFunctionCallPrefix)) {
+        return '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;
+}
 //# sourceMappingURL=default-builtin-config.js.map

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

@@ -52,7 +52,7 @@ function resolveByName(name, environment, target = identifier_1.ReferenceType.Un
     do {
         const definition = current.memory.get(name);
         if (definition !== undefined) {
-            const filtered = definition.filter(wantedType);
+            const filtered = target === identifier_1.ReferenceType.Unknown ? definition : definition.filter(wantedType);
             if (filtered.length === definition.length && definition.every(d => (0, info_1.happensInEveryBranch)(d.controlDependencies))) {
                 return definition;
             }
@@ -65,7 +65,7 @@ function resolveByName(name, environment, target = identifier_1.ReferenceType.Un
     } while (current.id !== environment_1.BuiltInEnvironment.id);
     const builtIns = current.memory.get(name);
     if (definitions) {
-        return builtIns === undefined ? definitions : [...definitions, ...builtIns];
+        return builtIns === undefined ? definitions : definitions.concat(builtIns);
     }
     else {
         return builtIns;
@@ -112,7 +112,7 @@ const AliasHandler = {
     [vertex_1.VertexType.VariableDefinition]: () => undefined
 };
 function getUseAlias(sourceId, dataflow, environment) {
-    const definitions = [];
+    let definitions = [];
     // Source is Symbol -> resolve definitions of symbol
     const identifier = (0, node_id_1.recoverName)(sourceId, dataflow.idMap);
     if (identifier === undefined) {
@@ -129,7 +129,7 @@ function getUseAlias(sourceId, dataflow, environment) {
             if (def.value === undefined) {
                 return undefined;
             }
-            definitions.push(...def.value);
+            definitions = definitions.concat(def.value);
         }
         else if (def.type === identifier_1.ReferenceType.Constant || def.type === identifier_1.ReferenceType.BuiltInConstant) {
             definitions.push(def.nodeId);
@@ -242,8 +242,19 @@ function trackAliasesInGraph(id, graph, idMap) {
             resultIds.push(id);
             continue;
         }
+        else if (vertex.tag === vertex_1.VertexType.FunctionDefinition) {
+            resultIds.push(id);
+            continue;
+        }
+        const isFn = vertex.tag === vertex_1.VertexType.FunctionCall;
         // travel all read and defined-by edges
         for (const [targetId, edge] of outgoingEdges) {
+            if (isFn) {
+                if (edge.types === edge_1.EdgeType.Returns || edge.types === edge_1.EdgeType.DefinedByOnCall || edge.types === edge_1.EdgeType.DefinedBy) {
+                    queue.add(targetId, baseEnvironment, cleanFingerprint, false);
+                }
+                continue;
+            }
             // currently, they have to be exact!
             if (edge.types === edge_1.EdgeType.Reads || edge.types === edge_1.EdgeType.DefinedBy || edge.types === edge_1.EdgeType.DefinedByOnCall) {
                 queue.add(targetId, baseEnvironment, cleanFingerprint, false);

package/dataflow/extractor.js

@@ -16,7 +16,7 @@ const range_1 = require("../util/range");
 const type_1 = require("../r-bridge/lang-4.x/ast/model/type");
 const environment_1 = require("./environments/environment");
 const built_in_source_1 = require("./internal/process/functions/call/built-in/built-in-source");
-const cfg_1 = require("../util/cfg/cfg");
+const extract_cfg_1 = require("../control-flow/extract-cfg");
 const edge_1 = require("./graph/edge");
 const identify_link_to_last_call_relation_1 = require("../queries/catalog/call-context-query/identify-link-to-last-call-relation");
 const built_in_function_definition_1 = require("./internal/process/functions/call/built-in/built-in-function-definition");
@@ -63,7 +63,7 @@ function resolveLinkToSideEffects(ast, graph) {
         if (typeof s !== 'object') {
             continue;
         }
-        cfg ??= (0, cfg_1.extractCFG)(ast, graph).graph;
+        cfg ??= (0, extract_cfg_1.extractSimpleCfg)(ast).graph;
         /* this has to change whenever we add a new link to relations because we currently offer no abstraction for the type */
         const potentials = (0, identify_link_to_last_call_relation_1.identifyLinkToLastCallRelation)(s.id, cfg, graph, s.linkTo);
         for (const pot of potentials) {

package/dataflow/graph/dataflowgraph-builder.d.ts

@@ -3,7 +3,7 @@ import type { AstIdMap } from '../../r-bridge/lang-4.x/ast/model/processing/deco
 import type { DataflowFunctionFlowInformation, FunctionArgument } from './graph';
 import { DataflowGraph } from './graph';
 import type { REnvironmentInformation } from '../environments/environment';
-import type { DataflowGraphVertexUse } from './vertex';
+import type { DataflowGraphVertexAstLink, DataflowGraphVertexUse, FunctionOriginInformation } from './vertex';
 import type { ControlDependency } from '../info';
 import type { LinkTo } from '../../queries/catalog/call-context-query/call-context-query-format';
 import type { FlowrSearchLike } from '../../search/flowr-search-builder';
@@ -47,6 +47,8 @@ export declare class DataflowGraphBuilder extends DataflowGraph {
         onlyBuiltIn?: boolean;
         environment?: REnvironmentInformation;
         controlDependencies?: ControlDependency[];
+        origin?: FunctionOriginInformation[];
+        link?: DataflowGraphVertexAstLink;
     }, asRoot?: boolean): this;
     /** automatically adds argument links if they do not already exist */
     private addArgumentLinks;

package/dataflow/graph/dataflowgraph-builder.js

@@ -61,7 +61,7 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
      * (i.e., be a valid entry point), or is it nested (e.g., as part of a function definition)
      */
     call(id, name, args, info, asRoot = true) {
-        const onlyBuiltInAuto = info?.reads?.length === 1 && info?.reads[0] === built_in_1.BuiltIn;
+        const onlyBuiltInAuto = info?.reads?.length === 1 && (0, built_in_1.isBuiltIn)(info?.reads[0]);
         this.addVertex({
             tag: vertex_1.VertexType.FunctionCall,
             id: (0, node_id_1.normalizeIdToNumberIfPossible)(id),
@@ -69,7 +69,9 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
             args: args.map(a => a === r_function_call_1.EmptyArgument ? r_function_call_1.EmptyArgument : { ...a, nodeId: (0, node_id_1.normalizeIdToNumberIfPossible)(a.nodeId), controlDependencies: undefined }),
             environment: (info?.onlyBuiltIn || onlyBuiltInAuto) ? undefined : info?.environment ?? (0, environment_1.initializeCleanEnvironments)(),
             cds: info?.controlDependencies?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })),
-            onlyBuiltin: info?.onlyBuiltIn ?? onlyBuiltInAuto ?? false
+            onlyBuiltin: info?.onlyBuiltIn ?? onlyBuiltInAuto ?? false,
+            origin: info?.origin ?? [(0, default_builtin_config_1.getDefaultProcessor)(name) ?? 'function'],
+            link: info?.link
         }, asRoot);
         this.addArgumentLinks(id, args);
         if (info?.returns) {

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

@@ -0,0 +1,16 @@
+import type { FunctionArgument, OutgoingEdges } from './graph';
+import type { GenericDiffConfiguration, GenericDifferenceInformation } from '../../util/diff';
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { GraphDiffContext, NamedGraph } from '../../util/diff-graph';
+import { GraphDifferenceReport } from '../../util/diff-graph';
+/**
+ * Compare two dataflow graphs and return a report on the differences.
+ * If you simply want to check whether they equal, use {@link GraphDifferenceReport#isEqual|`<result>.isEqual()`}.
+ *
+ * @see {@link diffOfControlFlowGraphs} - for control flow graphs
+ */
+export declare function diffOfDataflowGraphs(left: NamedGraph, right: NamedGraph, config?: Partial<GenericDiffConfiguration>): GraphDifferenceReport;
+export declare function equalFunctionArguments(fn: NodeId, a: false | readonly FunctionArgument[], b: false | readonly FunctionArgument[]): boolean;
+export declare function diffFunctionArguments(fn: NodeId, a: false | readonly FunctionArgument[], b: false | readonly FunctionArgument[], ctx: GenericDifferenceInformation<GraphDifferenceReport>): void;
+export declare function diffVertices(ctx: GraphDiffContext): void;
+export declare function diffEdges(ctx: GraphDiffContext, id: NodeId, lEdges: OutgoingEdges | undefined, rEdges: OutgoingEdges | undefined): void;

package/dataflow/graph/{diff.js → diff-dataflow-graph.js}

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataflowDifferenceReport = void 0;
 exports.diffOfDataflowGraphs = diffOfDataflowGraphs;
 exports.equalFunctionArguments = equalFunctionArguments;
 exports.diffFunctionArguments = diffFunctionArguments;
@@ -9,59 +8,29 @@ exports.diffEdges = diffEdges;
 const graph_1 = require("./graph");
 const diff_1 = require("../../util/diff");
 const json_1 = require("../../util/json");
-const arrays_1 = require("../../util/arrays");
+const arrays_1 = require("../../util/collections/arrays");
 const vertex_1 = require("./vertex");
 const edge_1 = require("./edge");
 const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
 const diff_2 = require("../environments/diff");
 const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const info_1 = require("../info");
-class DataflowDifferenceReport {
-    _comments = undefined;
-    _problematic = undefined;
-    addComment(comment, ...related) {
-        if (this._comments === undefined) {
-            this._comments = [comment];
-        }
-        else {
-            this._comments.push(comment);
-        }
-        if (related.length > 0) {
-            if (this._problematic === undefined) {
-                this._problematic = [...related];
-            }
-            else {
-                this._problematic.push(...related);
-            }
-        }
-    }
-    comments() {
-        return this._comments;
-    }
-    problematic() {
-        return this._problematic;
-    }
-    isEqual() {
-        return this._comments === undefined;
+const diff_graph_1 = require("../../util/diff-graph");
+/**
+ * Compare two dataflow graphs and return a report on the differences.
+ * If you simply want to check whether they equal, use {@link GraphDifferenceReport#isEqual|`<result>.isEqual()`}.
+ *
+ * @see {@link diffOfControlFlowGraphs} - for control flow graphs
+ */
+function diffOfDataflowGraphs(left, right, config) {
+    if (left.graph === right.graph) {
+        return new diff_graph_1.GraphDifferenceReport();
     }
+    const ctx = (0, diff_graph_1.initDiffContext)(left, right, config);
+    diffDataflowGraph(ctx);
+    return ctx.report;
 }
-exports.DataflowDifferenceReport = DataflowDifferenceReport;
-function initDiffContext(left, right, config) {
-    return {
-        left: left.graph,
-        leftname: left.name,
-        right: right.graph,
-        rightname: right.name,
-        report: new DataflowDifferenceReport(),
-        position: '',
-        config: {
-            rightIsSubgraph: false,
-            leftIsSubgraph: false,
-            ...config
-        }
-    };
-}
-function diff(ctx) {
+function diffDataflowGraph(ctx) {
     diffRootVertices(ctx);
     diffVertices(ctx);
     diffOutgoingEdges(ctx);
@@ -102,14 +71,6 @@ function diffRootVertices(ctx) {
     (0, diff_1.setDifference)(ctx.left.rootIds(), ctx.right.rootIds(), { ...ctx, position: `${ctx.position}Root vertices differ in graphs. ` });
     (0, diff_1.setDifference)(new Set([...ctx.left.unknownSideEffects].map(n => typeof n === 'object' ? n.id : n)), new Set([...ctx.right.unknownSideEffects].map(n => typeof n === 'object' ? n.id : n)), { ...ctx, position: `${ctx.position}Unknown side effects differ in graphs. ` });
 }
-function diffOfDataflowGraphs(left, right, config) {
-    if (left.graph === right.graph) {
-        return new DataflowDifferenceReport();
-    }
-    const ctx = initDiffContext(left, right, config);
-    diff(ctx);
-    return ctx.report;
-}
 function diffFunctionArgumentsReferences(fn, a, b, ctx) {
     if (a === '<value>' || b === '<value>') {
         if (a !== b) {
@@ -121,7 +82,7 @@ function diffFunctionArgumentsReferences(fn, a, b, ctx) {
 }
 function equalFunctionArguments(fn, a, b) {
     const ctx = {
-        report: new DataflowDifferenceReport(),
+        report: new diff_graph_1.GraphDifferenceReport(),
         leftname: 'left',
         rightname: 'right',
         position: '',
@@ -200,6 +161,19 @@ function diffVertices(ctx) {
             }
         }
         (0, info_1.diffControlDependencies)(lInfo.cds, rInfo.cds, { ...ctx, position: `Vertex ${id} differs in controlDependencies. ` });
+        if (lInfo.origin !== undefined || rInfo.origin !== undefined) {
+            // compare arrays
+            const equalArrays = lInfo.origin && rInfo.origin && (0, arrays_1.arrayEqual)(lInfo.origin, rInfo.origin);
+            if (!equalArrays) {
+                ctx.report.addComment(`Vertex ${id} differs in origin. ${ctx.leftname}: ${JSON.stringify(lInfo.origin, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(rInfo.origin, json_1.jsonReplacer)}`, { tag: 'vertex', id });
+            }
+        }
+        if (lInfo.link !== undefined || rInfo.link !== undefined) {
+            const equal = lInfo.link && rInfo.link && (0, arrays_1.arrayEqual)(lInfo.link.origin, rInfo.link.origin);
+            if (!equal) {
+                ctx.report.addComment(`Vertex ${id} differs in link. ${ctx.leftname}: ${JSON.stringify(lInfo.link, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(rInfo.link, json_1.jsonReplacer)}`, { tag: 'vertex', id });
+            }
+        }
         if ((lInfo.environment === undefined && rInfo.environment !== undefined && !ctx.config.leftIsSubgraph)
             || (lInfo.environment !== undefined && rInfo.environment === undefined && !ctx.config.rightIsSubgraph)) {
             /* only diff them if specified at all */
@@ -282,4 +256,4 @@ function diffEdges(ctx, id, lEdges, rEdges) {
         diffEdge(edge, otherEdge, ctx, id, target);
     }
 }
-//# sourceMappingURL=diff.js.map
+//# sourceMappingURL=diff-dataflow-graph.js.map

package/dataflow/graph/graph.d.ts

@@ -99,7 +99,7 @@ export type UnknownSidEffect = NodeId | {
  * @see {@link DataflowGraph#addEdge|`addEdge`} - to add an edge to the graph
  * @see {@link DataflowGraph#addVertex|`addVertex`} - to add a vertex to the graph
  * @see {@link DataflowGraph#fromJson|`fromJson`} - to construct a dataflow graph object from a deserialized JSON object.
- * @see {@link emptyGraph} - to create an empty graph (useful in tests)
+ * @see {@link emptyGraph|`emptyGraph`} - to create an empty graph (useful in tests)
  */
 export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = DataflowGraphVertexInfo, Edge extends DataflowGraphEdge = DataflowGraphEdge> {
     private static DEFAULT_ENVIRONMENT;
@@ -136,6 +136,13 @@ export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = Data
     getVertex(id: NodeId, includeDefinedFunctions?: boolean): Vertex | undefined;
     outgoingEdges(id: NodeId): OutgoingEdges | undefined;
     ingoingEdges(id: NodeId): IngoingEdges | undefined;
+    /**
+     * Given a node in the normalized AST this either:
+     * * returns the id if the node directly exists in the DFG
+     * * returns the ids of all vertices in the DFG that are linked to this
+     * * returns undefined if the node is not part of the DFG and not linked to any node
+     */
+    getLinked(nodeId: NodeId): NodeId[] | undefined;
     /** Retrieves the id-map to the normalized AST attached to the dataflow graph */
     get idMap(): AstIdMap | undefined;
     get sourced(): (string | '<inline>')[];
@@ -178,11 +185,12 @@ export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = Data
      * @param vertex - The vertex to add
      * @param asRoot - If false, this will only add the vertex but do not add it to the {@link rootIds|root vertices} of the graph.
      *                 This is probably only of use, when you construct dataflow graphs for tests.
+     * @param overwrite - If true, this will overwrite the vertex if it already exists in the graph (based on the id).
      *
      * @see DataflowGraphVertexInfo
      * @see DataflowGraphVertexArgument
      */
-    addVertex(vertex: DataflowGraphVertexArgument & Omit<Vertex, keyof DataflowGraphVertexArgument>, asRoot?: boolean): this;
+    addVertex(vertex: DataflowGraphVertexArgument & Omit<Vertex, keyof DataflowGraphVertexArgument>, asRoot?: boolean, overwrite?: boolean): this;
     /** {@inheritDoc} */
     addEdge(from: NodeId, to: NodeId, type: EdgeType | number): this;
     /** {@inheritDoc} */
@@ -211,7 +219,7 @@ export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = Data
     /** If you do not pass the `to` node, this will just mark the node as maybe */
     addControlDependency(from: NodeId, to?: NodeId, when?: boolean): this;
     /** Marks the given node as having unknown side effects */
-    markIdForUnknownSideEffects(id: NodeId, target?: LinkTo<RegExp | string>): this;
+    markIdForUnknownSideEffects(id: NodeId, target?: LinkTo): this;
     /**
      * Constructs a dataflow graph instance from the given JSON data and returns the result.
      * This can be useful for data sent by the flowR server when analyzing it further.

package/dataflow/graph/graph.js

@@ -5,15 +5,14 @@ exports.isPositionalArgument = isPositionalArgument;
 exports.isNamedArgument = isNamedArgument;
 exports.getReferenceOfArgument = getReferenceOfArgument;
 const assert_1 = require("../../util/assert");
-const diff_1 = require("./diff");
+const diff_dataflow_graph_1 = require("./diff-dataflow-graph");
 const vertex_1 = require("./vertex");
-const arrays_1 = require("../../util/arrays");
+const arrays_1 = require("../../util/collections/arrays");
 const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
 const environment_1 = require("../environments/environment");
 const clone_1 = require("../environments/clone");
 const json_1 = require("../../util/json");
-const built_in_1 = require("../environments/built-in");
 const logger_1 = require("../logger");
 /**
  * Check if the given argument is a {@link PositionalFunctionArgument}.
@@ -50,7 +49,7 @@ function getReferenceOfArgument(arg) {
  * @see {@link DataflowGraph#addEdge|`addEdge`} - to add an edge to the graph
  * @see {@link DataflowGraph#addVertex|`addVertex`} - to add a vertex to the graph
  * @see {@link DataflowGraph#fromJson|`fromJson`} - to construct a dataflow graph object from a deserialized JSON object.
- * @see {@link emptyGraph} - to create an empty graph (useful in tests)
+ * @see {@link emptyGraph|`emptyGraph`} - to create an empty graph (useful in tests)
  */
 class DataflowGraph {
     static DEFAULT_ENVIRONMENT = undefined;
@@ -111,6 +110,24 @@ class DataflowGraph {
         }
         return edges;
     }
+    /**
+     * Given a node in the normalized AST this either:
+     * * returns the id if the node directly exists in the DFG
+     * * returns the ids of all vertices in the DFG that are linked to this
+     * * returns undefined if the node is not part of the DFG and not linked to any node
+     */
+    getLinked(nodeId) {
+        if (this.vertexInformation.has(nodeId)) {
+            return [nodeId];
+        }
+        const linked = [];
+        for (const [id, vtx] of this.vertexInformation) {
+            if (vtx.link?.origin.includes(nodeId)) {
+                linked.push(id);
+            }
+        }
+        return linked.length > 0 ? linked : undefined;
+    }
     /** Retrieves the id-map to the normalized AST attached to the dataflow graph */
     get idMap() {
         return this._idMap;
@@ -180,13 +197,14 @@ class DataflowGraph {
      * @param vertex - The vertex to add
      * @param asRoot - If false, this will only add the vertex but do not add it to the {@link rootIds|root vertices} of the graph.
      *                 This is probably only of use, when you construct dataflow graphs for tests.
+     * @param overwrite - If true, this will overwrite the vertex if it already exists in the graph (based on the id).
      *
      * @see DataflowGraphVertexInfo
      * @see DataflowGraphVertexArgument
      */
-    addVertex(vertex, asRoot = true) {
+    addVertex(vertex, asRoot = true, overwrite = false) {
         const oldVertex = this.vertexInformation.get(vertex.id);
-        if (oldVertex !== undefined) {
+        if (oldVertex !== undefined && !overwrite) {
             return this;
         }
         const fallback = vertex.tag === vertex_1.VertexType.VariableDefinition || vertex.tag === vertex_1.VertexType.Use || vertex.tag === vertex_1.VertexType.Value || (vertex.tag === vertex_1.VertexType.FunctionCall && vertex.onlyBuiltin) ? undefined : DataflowGraph.DEFAULT_ENVIRONMENT;
@@ -201,12 +219,9 @@ class DataflowGraph {
         }
         return this;
     }
-    /**
-     * Please note that this will never make edges to {@link BuiltIn} as they are not part of the graph.
-     */
     addEdge(from, to, type) {
         const [fromId, toId] = extractEdgeIds(from, to);
-        if (fromId === toId || toId === built_in_1.BuiltIn) {
+        if (fromId === toId) {
             return this;
         }
         /* we now that we pass all required arguments */
@@ -244,7 +259,7 @@ class DataflowGraph {
                 this.rootVertices.add(root);
             }
         }
-        this.sourced.push(...otherGraph.sourced);
+        this._sourced = this._sourced.concat(otherGraph.sourced);
         for (const unknown of otherGraph.unknownSideEffects) {
             this._unknownSideEffects.add(unknown);
         }
@@ -357,7 +372,7 @@ function mergeNodeInfos(current, next) {
         (0, assert_1.guard)(current.scope === next.scope, 'nodes to be joined for the same id must have the same scope');
     }
     else if (current.tag === vertex_1.VertexType.FunctionCall) {
-        (0, assert_1.guard)((0, diff_1.equalFunctionArguments)(current.id, current.args, next.args), 'nodes to be joined for the same id must have the same function call information');
+        (0, assert_1.guard)((0, diff_dataflow_graph_1.equalFunctionArguments)(current.id, current.args, next.args), 'nodes to be joined for the same id must have the same function call information');
     }
     else if (current.tag === vertex_1.VertexType.FunctionDefinition) {
         (0, assert_1.guard)(current.scope === next.scope, 'nodes to be joined for the same id must have the same scope');