@eagleoutice/flowr 2.2.11 → 2.2.13

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

@@ -1,9 +1,94 @@
 "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', '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', '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
+];
+const GraphicDeviceOpen = [
+    'pdf', 'jpeg', 'png', 'windows', 'postscript', 'xfig', 'bitmap', 'pictex', 'cairo_pdf', 'svg', 'bmp', 'tiff', 'X11', 'quartz', 'image_graph',
+    'image_draw', 'dev.new', 'trellis.device', 'raster_pdf', 'agg_pdf'
+];
+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', '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'
+];
+function toRegex(n) {
+    return new RegExp(`^(${[...new Set(n)].map(s => s.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')).filter(s => s.length > 0).join('|')})$`);
+}
 /**
  * Contains the built-in definitions recognized by flowR
  */
@@ -20,7 +105,8 @@ exports.DefaultBuiltinConfig = [
             'unique', 'paste', 'paste0', 'read.csv', 'stop', 'is.null', 'numeric', 'as.character', 'as.integer', 'as.logical', 'as.numeric', 'as.matrix',
             'rbind', 'nrow', 'ncol', 'tryCatch', 'expression', 'factor',
             'missing', 'as.data.frame', 'data.frame', 'na.omit', 'rownames', 'names', 'order', 'length', 'any', 'dim', 'matrix', 'cbind', 'nchar',
-            'pdf', 'jpeg', 'png', 'windows', 'postscript', 'xfig', 'bitmap', 'pictex', 'cairo_pdf', 'svg', 'bmp', 'tiff', 'X11', 'quartz'
+            'pdf', 'jpeg', 'png', 'windows', 'postscript', 'xfig', 'bitmap', 'pictex', 'cairo_pdf', 'svg', 'bmp', 'tiff', 'X11', 'quartz',
+            'jitter'
         ],
         processor: 'builtin:default',
         config: { readAllArguments: true },
@@ -29,12 +115,13 @@ exports.DefaultBuiltinConfig = [
     {
         type: 'function',
         names: [
-            'c', 't', 'aperm' /* vector construction, concatenation, transpose function, permutation generation */
+            't', 'aperm' /* transpose function, permutation generation */
         ],
         processor: 'builtin:default',
         config: { readAllArguments: true },
         assumePrimitive: false
     },
+    { type: 'function', names: ['rm'], processor: 'builtin:rm', config: {}, assumePrimitive: true },
     { type: 'function', names: ['options'], processor: 'builtin:default', config: { hasUnknownSideEffects: true, forceArgs: 'all' }, assumePrimitive: false },
     { type: 'function', names: ['mapply', 'Mapply'], processor: 'builtin:apply', config: { indexOfFunction: 0, nameOfFunctionArgument: 'FUN' }, assumePrimitive: false },
     { type: 'function', names: ['lapply', 'sapply', 'vapply'], processor: 'builtin:apply', config: { indexOfFunction: 1, nameOfFunctionArgument: 'FUN' }, assumePrimitive: false },
@@ -42,7 +129,7 @@ exports.DefaultBuiltinConfig = [
     { type: 'function', names: ['apply', 'tapply', 'Tapply'], processor: 'builtin:apply', config: { indexOfFunction: 2, nameOfFunctionArgument: 'FUN' }, assumePrimitive: false },
     { type: 'function', names: ['print', 'message', 'warning'], processor: 'builtin:default', config: { returnsNthArgument: 0, forceArgs: 'all', hasUnknownSideEffects: { type: 'link-to-last-call', callName: /^sink$/ } }, assumePrimitive: false },
     // graphics base
-    { type: 'function', names: ['plot', 'plot.new', 'curve', 'map', 'image', 'boxplot', 'dotchart', 'sunflowerplot', 'barplot', 'matplot', 'hist', 'stem', 'density', 'smoothScatter', 'contour', 'persp'],
+    { type: 'function', names: PlotCreate,
         processor: 'builtin:default',
         config: {
             forceArgs: 'all',
@@ -50,26 +137,29 @@ 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);
                 },
-                callName: /^(pdf|jpeg|png|windows|postscript|xfig|bitmap|pictex|cairo_pdf|svg|bmp|tiff|X11|quartz)$/
+                callName: toRegex(GraphicDeviceOpen)
             }
         }, assumePrimitive: true },
     // graphics addons
-    { type: 'function', names: ['points', 'abline', 'map', 'mtext', 'lines', 'text', 'legend', 'title', 'axis', 'polygon', 'polypath', 'pie', 'rect', 'segments', 'arrows', 'symbols', 'tiplabels'],
+    { type: 'function', names: PlotAddons,
         processor: 'builtin:default', config: {
             forceArgs: 'all',
+            treatAsFnCall: {
+                'facet_grid': ['labeller']
+            },
             hasUnknownSideEffects: {
                 type: 'link-to-last-call',
-                callName: /^(dev\.new|dev\.copy|plot\.new|xspline|sunflowerplot|dotchart|plot|map|image|curve|boxplot|barplot|matplot|hist|stem|density|smoothScatter|contour|persp)$/,
+                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);
                 },
@@ -82,9 +172,47 @@ exports.DefaultBuiltinConfig = [
                 }
             }
         }, assumePrimitive: true },
+    // plot tags
+    {
+        type: 'function',
+        names: GgPlotAddons,
+        processor: 'builtin:default',
+        config: {
+            forceArgs: 'all',
+            hasUnknownSideEffects: {
+                type: 'link-to-last-call',
+                callName: toRegex([...GgPlotCreate, ...GgPlotAddons])
+            }
+        }, assumePrimitive: true
+    },
+    {
+        type: 'function',
+        names: TinyPlotAddons,
+        processor: 'builtin:default',
+        config: {
+            forceArgs: 'all',
+            hasUnknownSideEffects: {
+                type: 'link-to-last-call',
+                callName: toRegex([...TinyPlotCrate, ...TinyPlotAddons])
+            }
+        }, assumePrimitive: true
+    },
+    {
+        type: 'function',
+        names: ['image_write', 'image_capture', 'dev.capture', 'dev.off'],
+        processor: 'builtin:default',
+        config: {
+            forceArgs: 'all',
+            hasUnknownSideEffects: {
+                type: 'link-to-last-call',
+                callName: toRegex([...GraphicDeviceOpen, ...PlotCreate, ...PlotAddons, ...GgPlotAddons, ...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: ['eval', 'body', 'formals', 'environment'], 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: ['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 */ }, assumePrimitive: false },
@@ -113,7 +241,11 @@ 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: ['.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 },
     {
         type: 'function',
         names: ['setnames', 'setNames', 'setkey', 'setkeyv', 'setindex', 'setindexv', 'setattr'],
@@ -128,7 +260,7 @@ exports.DefaultBuiltinConfig = [
     {
         type: 'function',
         names: [
-            'on.exit', 'sys.on.exit', 'par', 'sink',
+            '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) */
@@ -146,7 +278,26 @@ exports.DefaultBuiltinConfig = [
     {
         type: 'replacement',
         suffixes: ['<-', '<<-'],
-        names: ['[', '[[', '$', '@', 'names', 'dimnames', 'attributes', 'attr', 'class', 'levels', 'rownames', 'colnames', 'body', 'environment', 'formals']
+        names: ['[', '[[', 'names', 'dimnames', 'attributes', 'attr', 'class', 'levels', 'rownames', 'colnames', 'body', 'environment', 'formals'],
+        config: {
+            readIndices: true
+        }
+    },
+    {
+        type: 'replacement',
+        suffixes: ['<-', '<<-'],
+        names: ['$', '@'],
+        config: {
+            readIndices: false
+        }
     }
 ];
+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/define.d.ts

@@ -1,5 +1,9 @@
 import type { REnvironmentInformation } from './environment';
-import type { IdentifierDefinition } from './identifier';
+import type { IdentifierDefinition, InGraphIdentifierDefinition } from './identifier';
+/**
+ * assumes: existing is not undefined, the overwrite has indices
+ */
+export declare function mergeDefinitions(existing: readonly IdentifierDefinition[], definition: InGraphIdentifierDefinition): InGraphIdentifierDefinition[];
 /**
  * Insert the given `definition` --- defined within the given scope --- into the passed along `environments` will take care of propagation.
  * Does not modify the passed along `environments` in-place! It returns the new reference.

package/dataflow/environments/define.js

@@ -1,17 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeDefinitions = mergeDefinitions;
 exports.define = define;
 const assert_1 = require("../../util/assert");
 const environment_1 = require("./environment");
 const clone_1 = require("./clone");
 const vertex_1 = require("../graph/vertex");
+const config_1 = require("../../config");
 function defInEnv(newEnvironments, name, definition) {
     const existing = newEnvironments.memory.get(name);
     // When there are defined indices, merge the definitions
     const inGraphDefinition = definition;
-    if (existing !== undefined && inGraphDefinition.indicesCollection !== undefined && inGraphDefinition.controlDependencies === undefined) {
-        newEnvironments.memory.set(name, mergeDefinitions(existing, inGraphDefinition));
-        return;
+    if ((0, config_1.getConfig)().solver.pointerTracking &&
+        existing !== undefined &&
+        inGraphDefinition.controlDependencies === undefined) {
+        if (inGraphDefinition.indicesCollection !== undefined) {
+            newEnvironments.memory.set(name, mergeDefinitions(existing, inGraphDefinition));
+            return;
+        }
+        else if (existing?.flatMap(i => i.indicesCollection ?? []).length > 0) {
+            // When indices couldn't be resolved, but indices where defined before, just add the definition
+            existing.push(definition);
+            return;
+        }
     }
     // check if it is maybe or not
     if (existing === undefined || definition.controlDependencies === undefined) {
@@ -21,28 +32,43 @@ function defInEnv(newEnvironments, name, definition) {
         existing.push(definition);
     }
 }
+/**
+ * assumes: existing is not undefined, the overwrite has indices
+ */
 function mergeDefinitions(existing, definition) {
     // When new definition is not a single index, e.g., a list redefinition, then reset existing definition
     if (definition.indicesCollection?.some(indices => indices.isContainer)) {
         return [definition];
     }
-    const existingDefs = existing.map((def) => def).filter((def) => def !== undefined);
+    const existingDefs = existing.filter(assert_1.isNotUndefined);
     const overwriteIndices = definition.indicesCollection?.flatMap(indices => indices.indices) ?? [];
     // Compare existing and new definitions,
     // add new definitions and remove existing definitions that are overwritten by new definition
     const newExistingDefs = [];
+    const hasCache = new Set();
     for (const overwriteIndex of overwriteIndices) {
         for (const existingDef of existingDefs) {
-            if (existingDef.indicesCollection === undefined) {
+            // empty or missing
+            if (existingDef.indicesCollection === undefined || existingDef.indicesCollection.length === 0) {
+                const existingDefPrint = JSON.stringify(existingDef);
+                if (!hasCache.has(existingDefPrint)) {
+                    newExistingDefs.push(existingDef);
+                    hasCache.add(existingDefPrint);
+                }
                 continue;
             }
             const newIndicesCollection = overwriteContainerIndices(existingDef.indicesCollection, overwriteIndex);
             // if indices are now empty list, don't keep empty definition
             if (newIndicesCollection.length > 0) {
-                newExistingDefs.push({
+                const obj = {
                     ...existingDef,
                     indicesCollection: newIndicesCollection,
-                });
+                };
+                const objHash = JSON.stringify(obj);
+                if (!hasCache.has(objHash)) {
+                    newExistingDefs.push(obj);
+                    hasCache.add(objHash);
+                }
             }
         }
     }
@@ -57,7 +83,7 @@ function overwriteContainerIndices(existingIndices, overwriteIndex) {
         if ((0, vertex_1.isParentContainerIndex)(overwriteIndex)) {
             newIndices = [];
             for (const index of indices.indices) {
-                if (index.lexeme === overwriteIndex.lexeme && (0, vertex_1.isParentContainerIndex)(index)) {
+                if ((0, vertex_1.isSameIndex)(index, overwriteIndex) && (0, vertex_1.isParentContainerIndex)(index)) {
                     const overwriteSubIndices = overwriteIndex.subIndices.flatMap(a => a.indices);
                     let newSubIndices = index.subIndices;
                     for (const overwriteSubIndex of overwriteSubIndices) {
@@ -70,7 +96,7 @@ function overwriteContainerIndices(existingIndices, overwriteIndex) {
                         });
                     }
                 }
-                if (index.lexeme !== overwriteIndex.lexeme || !(0, vertex_1.isParentContainerIndex)(index)) {
+                if (!(0, vertex_1.isSameIndex)(index, overwriteIndex) || !(0, vertex_1.isParentContainerIndex)(index)) {
                     newIndices.push(index);
                 }
             }
@@ -81,7 +107,7 @@ function overwriteContainerIndices(existingIndices, overwriteIndex) {
         }
         else {
             // Filter existing indices with the same name
-            newIndices = indices.indices.filter(def => def.lexeme !== overwriteIndex.lexeme);
+            newIndices = indices.indices.filter(def => !(0, vertex_1.isSameIndex)(def, overwriteIndex));
         }
         if (indices.isContainer || newIndices.length > 0) {
             newIndicesCollection.push({

package/dataflow/environments/overwrite.js

@@ -4,6 +4,7 @@ exports.overwriteIEnvironmentWith = overwriteIEnvironmentWith;
 exports.overwriteEnvironment = overwriteEnvironment;
 const assert_1 = require("../../util/assert");
 const environment_1 = require("./environment");
+const log_1 = require("../../util/log");
 function anyIsMaybeOrEmpty(values) {
     if (values.length === 0) {
         return true;
@@ -19,6 +20,9 @@ function overwriteIEnvironmentWith(base, next, includeParent = true, applyCds) {
     (0, assert_1.guard)(base !== undefined && next !== undefined, 'can not overwrite environments with undefined');
     const map = new Map(base.memory);
     for (const [key, values] of next.memory) {
+        if (values.length > 1_000_000) {
+            log_1.log.warn(`Overwriting environment with ${values.length} definitions for ${key}`);
+        }
         const hasMaybe = applyCds?.length === 0 || applyCds !== undefined ? true : anyIsMaybeOrEmpty(values);
         if (hasMaybe) {
             const old = map.get(key);

package/dataflow/environments/remove.d.ts

@@ -0,0 +1,6 @@
+import type { REnvironmentInformation } from './environment';
+import type { Identifier } from './identifier';
+/**
+ * Removes all definitions of a given name from the environment.
+ */
+export declare function remove(name: Identifier, environment: REnvironmentInformation): REnvironmentInformation;

package/dataflow/environments/remove.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remove = remove;
+const environment_1 = require("./environment");
+const info_1 = require("../info");
+/**
+ * Removes all definitions of a given name from the environment.
+ */
+function remove(name, environment) {
+    let current = environment.current;
+    do {
+        const definition = current.memory.get(name);
+        if (definition !== undefined) {
+            current.memory.delete(name);
+            if (definition.every(d => (0, info_1.happensInEveryBranch)(d.controlDependencies))) {
+                break;
+            }
+        }
+        current = current.parent;
+    } while (current.id !== environment_1.BuiltInEnvironment.id);
+    // we never remove built ins
+    return environment;
+}
+//# sourceMappingURL=remove.js.map

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

@@ -52,20 +52,20 @@ 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;
             }
             else if (filtered.length > 0) {
                 definitions ??= [];
-                definitions.push(...filtered);
+                definitions = definitions.concat(filtered);
             }
         }
         current = current.parent;
     } 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) {