@eagleoutice/flowr 2.2.11 → 2.2.12

package/cli/repl/commands/repl-dataflow.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dataflowStarCommand = exports.dataflowCommand = void 0;
+exports.dataflowSimpleStarCommand = exports.dataflowSimplifiedCommand = exports.dataflowStarCommand = exports.dataflowCommand = void 0;
 const default_pipelines_1 = require("../../../core/steps/pipeline/default-pipelines");
 const retriever_1 = require("../../../r-bridge/retriever");
 const dfg_1 = require("../../../util/mermaid/dfg");
@@ -86,4 +86,38 @@ exports.dataflowStarCommand = {
         catch { /* do nothing this is a service thing */ }
     }
 };
+exports.dataflowSimplifiedCommand = {
+    description: `Get simplified mermaid code for the dataflow graph of R code, start with '${retriever_1.fileProtocol}' to indicate a file`,
+    usageExample: ':dataflowsimple',
+    aliases: ['ds', 'dfs'],
+    script: false,
+    fn: async (output, shell, remainingLine) => {
+        const result = await replGetDataflow(shell, handleString(remainingLine));
+        const mermaid = (0, dfg_1.graphToMermaid)({ graph: result.dataflow.graph, includeEnvironments: false, simplified: true }).string;
+        output.stdout(mermaid);
+        try {
+            const clipboard = await Promise.resolve().then(() => __importStar(require('clipboardy')));
+            clipboard.default.writeSync(mermaid);
+            output.stdout(formatInfo(output, 'mermaid code', result.dataflow['.meta'].timing));
+        }
+        catch { /* do nothing this is a service thing */ }
+    }
+};
+exports.dataflowSimpleStarCommand = {
+    description: 'Returns the URL to mermaid.live',
+    usageExample: ':dataflowsimple*',
+    aliases: ['ds*', 'dfs*'],
+    script: false,
+    fn: async (output, shell, remainingLine) => {
+        const result = await replGetDataflow(shell, handleString(remainingLine));
+        const mermaid = (0, dfg_1.graphToMermaidUrl)(result.dataflow.graph, false, undefined, true);
+        output.stdout(mermaid);
+        try {
+            const clipboard = await Promise.resolve().then(() => __importStar(require('clipboardy')));
+            clipboard.default.writeSync(mermaid);
+            output.stdout(formatInfo(output, 'mermaid url', result.dataflow['.meta'].timing));
+        }
+        catch { /* do nothing this is a service thing */ }
+    }
+};
 //# sourceMappingURL=repl-dataflow.js.map

package/config.d.ts

@@ -2,6 +2,7 @@ import type { MergeableRecord } from './util/objects';
 import Joi from 'joi';
 import type { BuiltInDefinitions } from './dataflow/environments/built-in-config';
 import type { KnownParser } from './r-bridge/parser';
+import type { DeepPartial } from 'ts-essentials';
 export declare enum VariableResolve {
     /** Don't resolve constants at all */
     Disabled = "disabled",
@@ -67,12 +68,21 @@ export interface FlowrConfigOptions extends MergeableRecord {
          * How to resolve variables and their values
          */
         readonly variables: VariableResolve;
+        /**
+         * Should we include eval(parse(text="...")) calls in the dataflow graph?
+         */
+        readonly evalStrings: boolean;
         /**
          * Whether to track pointers in the dataflow graph,
          * if not, the graph will be over-approximated wrt.
          * containers and accesses
          */
-        readonly pointerTracking: boolean;
+        readonly pointerTracking: boolean | {
+            /**
+             * The maximum number of indices tracked per obj with the pointer analysis (currently this focuses on initialization)
+             */
+            readonly maxIndexCount: number;
+        };
         /**
          * If lax source calls are active, flowR searches for sourced files much more freely,
          * based on the configurations you give it.
@@ -96,6 +106,11 @@ export interface FlowrConfigOptions extends MergeableRecord {
              * if it is relative.
              */
             readonly dropPaths: DropPathsOption;
+            /**
+             * How often the same file can be sourced within a single run?
+             * Please be aware: in case of cyclic sources this may not reach a fixpoint so give this a sensible limit.
+             */
+            readonly repeatedSourceLimit?: number;
         };
         /**
          * The configuration for flowR's slicer
@@ -139,8 +154,9 @@ export declare const flowrConfigFileSchema: Joi.ObjectSchema<any>;
 export declare function setConfigFile(file: string | undefined, workingDirectory?: string, forceLoad?: boolean): void;
 export declare function parseConfig(jsonString: string): FlowrConfigOptions | undefined;
 export declare function setConfig(config: FlowrConfigOptions): void;
-export declare function amendConfig(amendment: Partial<FlowrConfigOptions>): void;
+export declare function amendConfig(amendment: DeepPartial<FlowrConfigOptions>): void;
 export declare function getConfig(): FlowrConfigOptions;
 export declare function getEngineConfig<T extends EngineConfig['type']>(engine: T): EngineConfig & {
     type: T;
 } | undefined;
+export declare function isOverPointerAnalysisThreshold(count: number): boolean;

package/config.js

@@ -10,6 +10,7 @@ exports.setConfig = setConfig;
 exports.amendConfig = amendConfig;
 exports.getConfig = getConfig;
 exports.getEngineConfig = getEngineConfig;
+exports.isOverPointerAnalysisThreshold = isOverPointerAnalysisThreshold;
 const objects_1 = require("./util/objects");
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
@@ -70,12 +71,14 @@ exports.defaultConfigOptions = {
     defaultEngine: 'r-shell',
     solver: {
         variables: VariableResolve.Alias,
-        pointerTracking: false,
+        evalStrings: true,
+        pointerTracking: true,
         resolveSource: {
             dropPaths: DropPathsOption.No,
             ignoreCapitalization: true,
             inferWorkingDirectory: InferWorkingDirectory.ActiveScript,
-            searchPath: []
+            searchPath: [],
+            repeatedSourceLimit: 2
         },
         slicer: {
             threshold: 50
@@ -104,12 +107,16 @@ exports.flowrConfigFileSchema = joi_1.default.object({
     defaultEngine: joi_1.default.string().optional().valid('tree-sitter', 'r-shell').description('The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from the specified list will be used.'),
     solver: joi_1.default.object({
         variables: joi_1.default.string().valid(...Object.values(VariableResolve)).description('How to resolve variables and their values.'),
-        pointerTracking: joi_1.default.boolean().description('Whether to track pointers in the dataflow graph, if not, the graph will be over-approximated wrt. containers and accesses.'),
+        evalStrings: joi_1.default.boolean().description('Should we include eval(parse(text="...")) calls in the dataflow graph?'),
+        pointerTracking: joi_1.default.alternatives(joi_1.default.boolean(), joi_1.default.object({
+            maxIndexCount: joi_1.default.number().required().description('The maximum number of indices tracked per object with the pointer analysis.')
+        })).description('Whether to track pointers in the dataflow graph, if not, the graph will be over-approximated wrt. containers and accesses.'),
         resolveSource: joi_1.default.object({
             dropPaths: joi_1.default.string().valid(...Object.values(DropPathsOption)).description('Allow to drop the first or all parts of the sourced path, if it is relative.'),
             ignoreCapitalization: joi_1.default.boolean().description('Search for filenames matching in the lowercase.'),
             inferWorkingDirectory: joi_1.default.string().valid(...Object.values(InferWorkingDirectory)).description('Try to infer the working directory from the main or any script to analyze.'),
-            searchPath: joi_1.default.array().items(joi_1.default.string()).description('Additionally search in these paths.')
+            searchPath: joi_1.default.array().items(joi_1.default.string()).description('Additionally search in these paths.'),
+            repeatedSourceLimit: joi_1.default.number().optional().description('How often the same file can be sourced within a single run? Please be aware: in case of cyclic sources this may not reach a fixpoint so give this a sensible limit.')
         }).optional().description('If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if `ignoreSourceCalls` is set to false.'),
         slicer: joi_1.default.object({
             threshold: joi_1.default.number().optional().description('The maximum number of iterations to perform on a single function call during slicing.')
@@ -175,6 +182,19 @@ function getEngineConfig(engine) {
         return config.find(e => e.type == engine);
     }
 }
+function getPointerAnalysisThreshold() {
+    const config = getConfig().solver.pointerTracking;
+    if (typeof config === 'object') {
+        return config.maxIndexCount;
+    }
+    else {
+        return config ? 'unlimited' : 'disabled';
+    }
+}
+function isOverPointerAnalysisThreshold(count) {
+    const threshold = getPointerAnalysisThreshold();
+    return threshold !== 'unlimited' && (threshold === 'disabled' || count > threshold);
+}
 function loadConfigFromFile(configFile, workingDirectory) {
     if (configFile !== undefined) {
         if (path_1.default.isAbsolute(configFile) && fs_1.default.existsSync(configFile)) {

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

@@ -26,7 +26,7 @@ export interface BuiltInConstantDefinition<Value> extends BaseBuiltInDefinition
 export interface BuiltInFunctionDefinition<BuiltInProcessor extends BuiltInMappingName> extends BaseBuiltInDefinition {
     readonly type: 'function';
     readonly processor: BuiltInProcessor;
-    readonly config: ConfigOfBuiltInMappingName<BuiltInProcessor>;
+    readonly config?: ConfigOfBuiltInMappingName<BuiltInProcessor>;
 }
 /**
  * Define a built-in replacement (like `[` or `$`) and the processor to use.
@@ -35,6 +35,9 @@ export interface BuiltInFunctionDefinition<BuiltInProcessor extends BuiltInMappi
 export interface BuiltInReplacementDefinition extends BaseBuiltInDefinition {
     readonly type: 'replacement';
     readonly suffixes: readonly ('<<-' | '<-')[];
+    readonly config: {
+        readIndices: boolean;
+    };
 }
 export type BuiltInDefinition = BuiltInConstantDefinition<any> | BuiltInFunctionDefinition<any> | BuiltInReplacementDefinition;
 /**
@@ -42,6 +45,6 @@ export type BuiltInDefinition = BuiltInConstantDefinition<any> | BuiltInFunction
  */
 export type BuiltInDefinitions = readonly BuiltInDefinition[];
 export declare function registerBuiltInFunctions<BuiltInProcessor extends BuiltInMappingName>({ names, processor, config, assumePrimitive }: BuiltInFunctionDefinition<BuiltInProcessor>): void;
-export declare function registerReplacementFunctions({ names, suffixes, assumePrimitive }: BuiltInReplacementDefinition): void;
+export declare function registerReplacementFunctions({ names, suffixes, assumePrimitive, config }: BuiltInReplacementDefinition): void;
 export declare function registerBuiltInDefinition(definition: BuiltInDefinition): void;
 export declare function registerBuiltInDefinitions(definitions: BuiltInDefinitions): void;

package/dataflow/environments/built-in-config.js

@@ -34,6 +34,7 @@ function registerBuiltInFunctions({ names, processor, config, assumePrimitive })
                 controlDependencies: undefined,
                 /* eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-argument */
                 processor: (name, args, rootId, data) => mappedProcessor(name, args, rootId, data, config),
+                config,
                 name,
                 nodeId: built_in_1.BuiltIn
             }];
@@ -44,7 +45,7 @@ function registerBuiltInFunctions({ names, processor, config, assumePrimitive })
     }
 }
 /* registers all combinations of replacements */
-function registerReplacementFunctions({ names, suffixes, assumePrimitive }) {
+function registerReplacementFunctions({ names, suffixes, assumePrimitive, config }) {
     const replacer = built_in_1.BuiltInProcessorMapper['builtin:replacement'];
     (0, assert_1.guard)(replacer !== undefined, () => 'Processor for builtin:replacement is undefined!');
     for (const assignment of names) {
@@ -53,7 +54,12 @@ function registerReplacementFunctions({ names, suffixes, assumePrimitive }) {
             const d = [{
                     type: identifier_1.ReferenceType.BuiltInFunction,
                     definedAt: built_in_1.BuiltIn,
-                    processor: (name, args, rootId, data) => replacer(name, args, rootId, data, { makeMaybe: true, assignmentOperator: suffix }),
+                    processor: (name, args, rootId, data) => replacer(name, args, rootId, data, { makeMaybe: true, assignmentOperator: suffix, readIndices: config.readIndices }),
+                    config: {
+                        ...config,
+                        assignmentOperator: suffix,
+                        makeMaybe: true
+                    },
                     name: effectiveName,
                     controlDependencies: undefined,
                     nodeId: built_in_1.BuiltIn

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

@@ -25,6 +25,9 @@ import type { ForceArguments } from '../internal/process/functions/call/common';
 import { processApply } from '../internal/process/functions/call/built-in/built-in-apply';
 import type { LinkTo } from '../../queries/catalog/call-context-query/call-context-query-format';
 import { processList } from '../internal/process/functions/call/built-in/built-in-list';
+import { processVector } from '../internal/process/functions/call/built-in/built-in-vector';
+import { processRm } from '../internal/process/functions/call/built-in/built-in-rm';
+import { processEvalCall } from '../internal/process/functions/call/built-in/built-in-eval';
 export declare const BuiltIn = "built-in";
 export type BuiltInIdentifierProcessor = <OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>) => DataflowInformation;
 export type BuiltInIdentifierProcessorWithConfig<Config> = <OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: Config) => DataflowInformation;
@@ -32,6 +35,7 @@ export interface BuiltInIdentifierDefinition extends IdentifierReference {
     type: ReferenceType.BuiltInFunction;
     definedAt: typeof BuiltIn;
     processor: BuiltInIdentifierProcessor;
+    config?: object;
 }
 export interface BuiltInIdentifierConstant<T = unknown> extends IdentifierReference {
     type: ReferenceType.BuiltInConstant;
@@ -45,15 +49,17 @@ export interface DefaultBuiltInProcessorConfiguration extends ForceArguments {
     readonly hasUnknownSideEffects?: boolean | LinkTo<RegExp | string>;
 }
 declare function defaultBuiltInProcessor<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: DefaultBuiltInProcessorConfiguration): DataflowInformation;
-export declare function registerBuiltInFunctions<Config, Proc extends BuiltInIdentifierProcessorWithConfig<Config>>(both: boolean, names: readonly Identifier[], processor: Proc, config: Config): void;
+export declare function registerBuiltInFunctions<Config extends object, Proc extends BuiltInIdentifierProcessorWithConfig<Config>>(both: boolean, names: readonly Identifier[], processor: Proc, config: Config): void;
 export declare const BuiltInProcessorMapper: {
     readonly 'builtin:default': typeof defaultBuiltInProcessor;
+    readonly 'builtin:eval': typeof processEvalCall;
     readonly 'builtin:apply': typeof processApply;
     readonly 'builtin:expression-list': typeof processExpressionList;
     readonly 'builtin:source': typeof processSourceCall;
     readonly 'builtin:access': typeof processAccess;
     readonly 'builtin:if-then-else': typeof processIfThenElse;
     readonly 'builtin:get': typeof processGet;
+    readonly 'builtin:rm': typeof processRm;
     readonly 'builtin:library': typeof processLibrary;
     readonly 'builtin:assignment': typeof processAssignment;
     readonly 'builtin:special-bin-op': typeof processSpecialBinOp;
@@ -65,6 +71,7 @@ export declare const BuiltInProcessorMapper: {
     readonly 'builtin:while-loop': typeof processWhileLoop;
     readonly 'builtin:replacement': typeof processReplacementFunction;
     readonly 'builtin:list': typeof processList;
+    readonly 'builtin:vector': typeof processVector;
 };
 export type BuiltInMappingName = keyof typeof BuiltInProcessorMapper;
 export type ConfigOfBuiltInMappingName<N extends BuiltInMappingName> = Parameters<typeof BuiltInProcessorMapper[N]>[4];

package/dataflow/environments/built-in.js

@@ -25,6 +25,9 @@ const built_in_apply_1 = require("../internal/process/functions/call/built-in/bu
 const built_in_config_1 = require("./built-in-config");
 const default_builtin_config_1 = require("./default-builtin-config");
 const built_in_list_1 = require("../internal/process/functions/call/built-in/built-in-list");
+const built_in_vector_1 = require("../internal/process/functions/call/built-in/built-in-vector");
+const built_in_rm_1 = require("../internal/process/functions/call/built-in/built-in-rm");
+const built_in_eval_1 = require("../internal/process/functions/call/built-in/built-in-eval");
 exports.BuiltIn = 'built-in';
 function defaultBuiltInProcessor(name, args, rootId, data, config) {
     const { information: res, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs });
@@ -62,6 +65,7 @@ function registerBuiltInFunctions(both, names, processor, config) {
                 definedAt: exports.BuiltIn,
                 controlDependencies: undefined,
                 processor: (name, args, rootId, data) => processor(name, args, rootId, data, config),
+                config,
                 name,
                 nodeId: exports.BuiltIn
             }];
@@ -73,12 +77,14 @@ function registerBuiltInFunctions(both, names, processor, config) {
 }
 exports.BuiltInProcessorMapper = {
     'builtin:default': defaultBuiltInProcessor,
+    'builtin:eval': built_in_eval_1.processEvalCall,
     'builtin:apply': built_in_apply_1.processApply,
     'builtin:expression-list': built_in_expression_list_1.processExpressionList,
     'builtin:source': built_in_source_1.processSourceCall,
     'builtin:access': built_in_access_1.processAccess,
     'builtin:if-then-else': built_in_if_then_else_1.processIfThenElse,
     'builtin:get': built_in_get_1.processGet,
+    'builtin:rm': built_in_rm_1.processRm,
     'builtin:library': built_in_library_1.processLibrary,
     'builtin:assignment': built_in_assignment_1.processAssignment,
     'builtin:special-bin-op': built_in_special_bin_op_1.processSpecialBinOp,
@@ -89,7 +95,8 @@ exports.BuiltInProcessorMapper = {
     'builtin:repeat-loop': built_in_repeat_loop_1.processRepeatLoop,
     'builtin:while-loop': built_in_while_loop_1.processWhileLoop,
     'builtin:replacement': built_in_replacement_1.processReplacementFunction,
-    'builtin:list': built_in_list_1.processList
+    'builtin:list': built_in_list_1.processList,
+    'builtin:vector': built_in_vector_1.processVector,
 };
 exports.BuiltInMemory = new Map();
 exports.EmptyBuiltInMemory = new Map();

package/dataflow/environments/clone.d.ts

@@ -1,2 +1,7 @@
 import type { REnvironmentInformation } from './environment';
+/**
+ * Produce a clone of the given environment information.
+ * @param environment    - The environment information to clone.
+ * @param recurseParents - Whether to clone the parent environments as well.
+ */
 export declare function cloneEnvironmentInformation(environment: REnvironmentInformation, recurseParents?: boolean): REnvironmentInformation;

package/dataflow/environments/clone.js

@@ -14,6 +14,11 @@ function cloneEnvironment(environment, recurseParents) {
     clone.memory = new Map(JSON.parse(JSON.stringify([...environment.memory])));
     return clone;
 }
+/**
+ * Produce a clone of the given environment information.
+ * @param environment    - The environment information to clone.
+ * @param recurseParents - Whether to clone the parent environments as well.
+ */
 function cloneEnvironmentInformation(environment, recurseParents = true) {
     return {
         current: cloneEnvironment(environment.current, recurseParents),

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

@@ -4,6 +4,37 @@ exports.DefaultBuiltinConfig = void 0;
 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 GgPlotCreate = [
+    'ggplot', 'ggplotly'
+];
+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',
+    ...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 PlotAddons = [
+    'points', 'abline', 'map', 'mtext', 'lines', 'text', 'legend', 'title', 'axis', 'polygon', 'polypath', 'pie', 'rect', 'segments', 'arrows', 'symbols',
+    'tiplabels', 'rug', 'grid', 'box', 'clip'
+];
+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 +51,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 +61,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 +75,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',
@@ -55,16 +88,16 @@ exports.DefaultBuiltinConfig = [
                         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',
             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),
                 ignoreIf: (source, graph) => {
                     const sourceVertex = graph.getVertex(source);
                     /* map with add = true appends to an existing plot */
@@ -82,9 +115,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)
+            }
+        }, assumePrimitive: true
+    },
+    {
+        type: 'function',
+        names: TinyPlotAddons,
+        processor: 'builtin:default',
+        config: {
+            forceArgs: 'all',
+            hasUnknownSideEffects: {
+                type: 'link-to-last-call',
+                callName: toRegex(TinyPlotCrate)
+            }
+        }, 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 +184,9 @@ 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: ['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 +201,7 @@ exports.DefaultBuiltinConfig = [
     {
         type: 'function',
         names: [
-            'on.exit', 'sys.on.exit', 'par', 'sink',
+            'on.exit', 'sys.on.exit', 'par', 'tpar', 'sink', 'tinytheme',
             /* library and require is handled above */
             'requireNamespace', 'loadNamespace', 'attachNamespace', 'asNamespace',
             /* downloader and installer functions (R, devtools, BiocManager) */
@@ -146,7 +219,18 @@ 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
+        }
     }
 ];
 //# 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({