@eagleoutice/flowr 2.8.14 → 2.9.0

package/cli/common/options.js

@@ -23,7 +23,6 @@ exports.benchmarkOptions = [
     { name: 'output', alias: 'o', type: String, description: `Folder to write all the measurements to in a per-file-basis (defaults to {italic benchmark-${StartTimeString}})`, defaultValue: `benchmark-${StartTimeString}`, typeLabel: '{underline folder}' },
     { name: 'parser', type: String, description: 'The parser to use for the benchmark', defaultValue: 'r-shell', typeLabel: '{underline parser}' },
     { name: 'dataframe-shape-inference', type: Boolean, description: 'Infer the shape of data frames using abstract interpretation (includes control flow graph extraction)', defaultValue: false },
-    { name: 'enable-pointer-tracking', type: Boolean, description: 'Run dataflow analysis with pointer tracking', defaultValue: false },
     { name: 'max-file-slices', type: Number, description: 'If file has more than passed number of slices, the file is not processed', defaultValue: -1, typeLabel: '{underline number}' },
     { name: 'threshold', alias: 't', type: Number, description: 'How many re-visits of the same node are ok?', defaultValue: undefined, typeLabel: '{underline number}' },
     { name: 'per-file-time-limit', type: Number, description: 'Time limit in milliseconds to process single file (disabled by default)', defaultValue: undefined, typeLabel: '{underline number}' },
@@ -41,7 +40,6 @@ exports.benchmarkHelperOptions = [
     { name: 'output', alias: 'o', type: String, description: 'File to write the measurements to (appends a single line in JSON format)', typeLabel: '{underline file}' },
     { name: 'parser', type: String, description: 'The parser to use for the benchmark', defaultValue: 'r-shell', typeLabel: '{underline parser}' },
     { name: 'dataframe-shape-inference', type: Boolean, description: 'Infer the shape of data frames using abstract interpretation (includes control flow graph extraction)', defaultValue: false },
-    { name: 'enable-pointer-tracking', type: Boolean, description: 'Run dataflow analysis with pointer tracking', defaultValue: false },
     { name: 'max-slices', type: Number, description: 'If file has more than passed number of slices, the file is not processed', defaultValue: -1, typeLabel: '{underline number}' },
     { name: 'threshold', alias: 't', type: Number, description: 'How many re-visits of the same node are ok?', defaultValue: undefined, typeLabel: '{underline number}' },
     { name: 'sampling-strategy', type: String, description: 'Which strategy to use, when sampling is enabled', defaultValue: 'random', typeLabel: '{underline random/equidistant}' },

package/cli/common/scripts-info.d.ts

@@ -162,11 +162,6 @@ declare const _scripts: {
             readonly type: BooleanConstructor;
             readonly description: "Infer the shape of data frames using abstract interpretation (includes control flow graph extraction)";
             readonly defaultValue: false;
-        }, {
-            readonly name: "enable-pointer-tracking";
-            readonly type: BooleanConstructor;
-            readonly description: "Run dataflow analysis with pointer tracking";
-            readonly defaultValue: false;
         }, {
             readonly name: "max-file-slices";
             readonly type: NumberConstructor;
@@ -261,11 +256,6 @@ declare const _scripts: {
             readonly type: BooleanConstructor;
             readonly description: "Infer the shape of data frames using abstract interpretation (includes control flow graph extraction)";
             readonly defaultValue: false;
-        }, {
-            readonly name: "enable-pointer-tracking";
-            readonly type: BooleanConstructor;
-            readonly description: "Run dataflow analysis with pointer tracking";
-            readonly defaultValue: false;
         }, {
             readonly name: "max-slices";
             readonly type: NumberConstructor;

package/cli/repl/server/connection.js

@@ -256,7 +256,7 @@ class FlowRServerConnection {
                 type: 'response-slice',
                 id: request.id,
                 results: Object.fromEntries(Object.entries(result)
-                    .filter(([k,]) => default_pipelines_1.DEFAULT_SLICING_PIPELINE.steps.get(k)?.executed === 1 /* PipelineStepStage.OncePerRequest */))
+                    .filter(([k]) => default_pipelines_1.DEFAULT_SLICING_PIPELINE.steps.get(k)?.executed === 1 /* PipelineStepStage.OncePerRequest */))
             });
         }).catch(e => {
             this.logger.error(`[${this.name}] Error while analyzing file for token ${request.filetoken}: ${String(e)}`);

package/config.d.ts

@@ -131,17 +131,6 @@ export interface FlowrConfigOptions extends MergeableRecord {
          * 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 | {
-            /**
-             * The maximum number of indices tracked per obj with the pointer analysis (currently this focuses on initialization)
-             */
-            readonly maxIndexCount: number;
-        };
         /** These keys are only intended for use within code, allowing to instrument the dataflow analyzer! */
         readonly instrument: {
             /**
@@ -249,7 +238,3 @@ export declare function getConfig(configFile?: string, configWorkingDirectory?:
 export declare function getEngineConfig<T extends EngineConfig['type']>(config: FlowrConfigOptions, engine: T): EngineConfig & {
     type: T;
 } | undefined;
-/**
- * Checks whether the given count is over the pointer analysis threshold configured in the config.
- */
-export declare function isOverPointerAnalysisThreshold(config: FlowrConfigOptions, count: number): boolean;

package/config.js

@@ -9,7 +9,6 @@ exports.amendConfig = amendConfig;
 exports.cloneConfig = cloneConfig;
 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"));
@@ -77,7 +76,6 @@ exports.defaultConfigOptions = {
     solver: {
         variables: VariableResolve.Alias,
         evalStrings: true,
-        pointerTracking: false,
         resolveSource: {
             dropPaths: DropPathsOption.No,
             ignoreCapitalization: true,
@@ -133,9 +131,6 @@ exports.flowrConfigFileSchema = joi_1.default.object({
     solver: joi_1.default.object({
         variables: joi_1.default.string().valid(...Object.values(VariableResolve)).description('How to resolve variables and their values.'),
         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.'),
         instrument: joi_1.default.object({
             dataflowExtractors: joi_1.default.any().optional().description('These keys are only intended for use within code, allowing to instrument the dataflow analyzer!')
         }),
@@ -221,22 +216,6 @@ function getEngineConfig(config, engine) {
         return engines.find(e => e.type == engine);
     }
 }
-function getPointerAnalysisThreshold(config) {
-    const pointerTracking = config.solver.pointerTracking;
-    if (typeof pointerTracking === 'object') {
-        return pointerTracking.maxIndexCount;
-    }
-    else {
-        return pointerTracking ? 'unlimited' : 'disabled';
-    }
-}
-/**
- * Checks whether the given count is over the pointer analysis threshold configured in the config.
- */
-function isOverPointerAnalysisThreshold(config, count) {
-    const threshold = getPointerAnalysisThreshold(config);
-    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/control-flow/cfg-dead-code.js

@@ -107,9 +107,6 @@ class CfgConditionalDeadCodeRemoval extends semantic_cfg_guided_visitor_1.Semant
     onWhileLoopCall(data) {
         this.handleWithCondition(data);
     }
-    onReturnCall(data) {
-        this.cachedStatements.set(data.call.id, true);
-    }
     onStopCall(data) {
         this.cachedStatements.set(data.call.id, true);
     }

package/control-flow/extract-cfg.js

@@ -79,7 +79,7 @@ function extractCfgQuick(ast) {
 function getCallsInCfg(cfg, graph) {
     const calls = new Map();
     for (const vertexId of cfg.graph.vertices().keys()) {
-        const vertex = graph.getVertex(vertexId, true);
+        const vertex = graph.getVertex(vertexId);
         if ((0, vertex_1.isFunctionCallVertex)(vertex)) {
             calls.set(vertexId, vertex);
         }
@@ -332,6 +332,10 @@ function cfgFunctionCall(call, name, args, exit = 'exit') {
     for (const exit of lastArgExits) {
         graph.addEdge(callId + '-exit', exit, { label: 0 /* CfgEdgeType.Fd */ });
     }
+    if (call.named && call.functionName.content === 'return') {
+        info.returns.push(callId + '-exit');
+        info.exitPoints.length = 0;
+    }
     // should not contain any breaks, nexts, or returns, (except for the body if something like 'break()')
     return info;
 }

package/control-flow/semantic-cfg-guided-visitor.d.ts

@@ -534,4 +534,11 @@ export declare class SemanticCfgGuidedVisitor<OtherInfo = NoInfo, ControlFlow ex
     protected onReturnCall(_data: {
         call: DataflowGraphVertexFunctionCall;
     }): void;
+    /**
+     * This event triggers for every call to `Recall`, which is used to recall the function closure (usually in recursive functions).
+     * @protected
+     */
+    protected onRecallCall(_data: {
+        call: DataflowGraphVertexFunctionCall;
+    }): void;
 }

package/control-flow/semantic-cfg-guided-visitor.js

@@ -202,11 +202,11 @@ class SemanticCfgGuidedVisitor extends dfg_cfg_guided_visitor_1.DataflowAwareCfg
             case built_in_1.BuiltInProcName.TableAssignment: {
                 const outgoing = this.config.dfg.outgoingEdges(call.id);
                 if (outgoing) {
-                    const target = [...outgoing.entries()].filter(([, e]) => (0, edge_1.edgeIncludesType)(e.types, edge_1.EdgeType.Returns));
+                    const target = outgoing.entries().filter(([, e]) => edge_1.DfEdge.includesType(e, edge_1.EdgeType.Returns)).toArray();
                     if (target.length === 1) {
                         const targetOut = this.config.dfg.outgoingEdges(target[0][0]);
                         if (targetOut) {
-                            const source = [...targetOut.entries()].filter(([t, e]) => (0, edge_1.edgeIncludesType)(e.types, edge_1.EdgeType.DefinedBy) && t !== call.id);
+                            const source = [...targetOut.entries()].filter(([t, e]) => edge_1.DfEdge.includesType(e, edge_1.EdgeType.DefinedBy) && t !== call.id);
                             if (source.length === 1) {
                                 return this.onAssignmentCall({ call, target: target[0][0], source: source[0][0] });
                             }
@@ -236,11 +236,11 @@ class SemanticCfgGuidedVisitor extends dfg_cfg_guided_visitor_1.DataflowAwareCfg
             case built_in_1.BuiltInProcName.Replacement: {
                 const outgoing = this.config.dfg.outgoingEdges(call.id);
                 if (outgoing) {
-                    const target = [...outgoing.entries()].filter(([, e]) => (0, edge_1.edgeIncludesType)(e.types, edge_1.EdgeType.Returns));
+                    const target = outgoing.entries().filter(([, e]) => edge_1.DfEdge.includesType(e, edge_1.EdgeType.Returns)).toArray();
                     if (target.length === 1) {
                         const targetOut = this.config.dfg.outgoingEdges(target[0][0]);
                         if (targetOut) {
-                            const source = [...targetOut.entries()].filter(([t, e]) => (0, edge_1.edgeIncludesType)(e.types, edge_1.EdgeType.DefinedBy) && t !== call.id);
+                            const source = targetOut.entries().filter(([t, e]) => edge_1.DfEdge.includesType(e, edge_1.EdgeType.DefinedBy) && t !== call.id).toArray();
                             if (source.length === 1) {
                                 return this.onReplacementCall({ call, target: target[0][0], source: source[0][0] });
                             }
@@ -269,6 +269,8 @@ class SemanticCfgGuidedVisitor extends dfg_cfg_guided_visitor_1.DataflowAwareCfg
                 return this.onReturnCall({ call });
             case built_in_1.BuiltInProcName.Unnamed:
                 return this.onUnnamedCall({ call });
+            case built_in_1.BuiltInProcName.Recall:
+                return this.onRecallCall({ call });
             case built_in_1.BuiltInProcName.Default:
             case built_in_1.BuiltInProcName.Function:
             case built_in_1.BuiltInProcName.FunctionDefinition:
@@ -606,6 +608,11 @@ class SemanticCfgGuidedVisitor extends dfg_cfg_guided_visitor_1.DataflowAwareCfg
      * @protected
      */
     onReturnCall(_data) { }
+    /**
+     * This event triggers for every call to `Recall`, which is used to recall the function closure (usually in recursive functions).
+     * @protected
+     */
+    onRecallCall(_data) { }
 }
 exports.SemanticCfgGuidedVisitor = SemanticCfgGuidedVisitor;
 //# sourceMappingURL=semantic-cfg-guided-visitor.js.map

package/dataflow/cluster.js

@@ -35,9 +35,9 @@ function makeCluster(graph, from, notReached) {
         }
     }
     // cluster adjacent edges
-    for (const [dest, { types }] of [...graph.outgoingEdges(from) ?? [], ...graph.ingoingEdges(from) ?? []]) {
+    for (const [dest, e] of [...graph.outgoingEdges(from) ?? [], ...graph.ingoingEdges(from) ?? []]) {
         // don't cluster for function content if it isn't returned
-        if ((0, edge_1.edgeDoesNotIncludeType)(types, edge_1.EdgeType.Returns) && info.onlyBuiltin && info.name == '{') {
+        if (edge_1.DfEdge.doesNotIncludeType(e, edge_1.EdgeType.Returns) && info.onlyBuiltin && info.name == '{') {
             continue;
         }
         if (notReached.delete(dest)) {

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

@@ -39,6 +39,7 @@ export interface BuiltInReplacementDefinition extends BaseBuiltInDefinition {
     readonly suffixes: ('<<-' | '<-')[];
     readonly config: {
         readIndices: boolean;
+        libFn?: boolean;
     };
 }
 export type BuiltInDefinition<T extends keyof typeof BuiltInProcessorMapper = keyof typeof BuiltInProcessorMapper> = BuiltInConstantDefinition<unknown> | BuiltInFunctionDefinition<T> | BuiltInReplacementDefinition;

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

@@ -8,7 +8,7 @@ import { processPipe } from '../internal/process/functions/call/built-in/built-i
 import { processForLoop } from '../internal/process/functions/call/built-in/built-in-for-loop';
 import { processRepeatLoop } from '../internal/process/functions/call/built-in/built-in-repeat-loop';
 import { processWhileLoop } from '../internal/process/functions/call/built-in/built-in-while-loop';
-import { type Identifier, type IdentifierDefinition, type IdentifierReference, ReferenceType } from './identifier';
+import { type BrandedIdentifier, type IdentifierDefinition, type IdentifierReference, ReferenceType } from './identifier';
 import { processReplacementFunction } from '../internal/process/functions/call/built-in/built-in-replacement';
 import { processQuote } from '../internal/process/functions/call/built-in/built-in-quote';
 import { processFunctionDefinition } from '../internal/process/functions/call/built-in/built-in-function-definition';
@@ -39,6 +39,7 @@ import { processTryCatch } from '../internal/process/functions/call/built-in/bui
 import { processRegisterHook } from '../internal/process/functions/call/built-in/built-in-register-hook';
 import { processLocal } from '../internal/process/functions/call/built-in/built-in-local';
 import { processS3Dispatch } from '../internal/process/functions/call/built-in/built-in-s-three-dispatch';
+import { processRecall } from '../internal/process/functions/call/built-in/built-in-recall';
 export type BuiltIn = `built-in:${string}`;
 /**
  * Generate a built-in id for the given name
@@ -122,6 +123,10 @@ export declare enum BuiltInProcName {
     Pipe = "builtin:pipe",
     /** for `quote`, and other substituting calls, see {@link processQuote} */
     Quote = "builtin:quote",
+    /**
+     * for `recall` calls, see {@link processRecall}
+     */
+    Recall = "builtin:recall",
     /** for `on.exìt` and other hooks, see {@link processRegisterHook} */
     RegisterHook = "builtin:register-hook",
     /** for `repeat` loops, see {@link processRepeatLoop} */
@@ -170,6 +175,7 @@ export declare const BuiltInProcessorMapper: {
     readonly "builtin:local": typeof processLocal;
     readonly "builtin:pipe": typeof processPipe;
     readonly "builtin:quote": typeof processQuote;
+    readonly "builtin:recall": typeof processRecall;
     readonly "builtin:register-hook": typeof processRegisterHook;
     readonly "builtin:repeat-loop": typeof processRepeatLoop;
     readonly "builtin:replacement": typeof processReplacementFunction;
@@ -189,7 +195,7 @@ export declare const BuiltInEvalHandlerMapper: {
     readonly 'built-in:-': typeof resolveAsMinus;
 };
 export type ConfigOfBuiltInMappingName<N extends keyof typeof BuiltInProcessorMapper> = Parameters<typeof BuiltInProcessorMapper[N]>[4];
-export type BuiltInMemory = Map<Identifier, IdentifierDefinition[]>;
+export type BuiltInMemory = Map<BrandedIdentifier, IdentifierDefinition[]>;
 export declare class BuiltIns {
     /**
      * Register a built-in constant (like `NULL` or `TRUE`) to the given {@link BuiltIns}
@@ -221,6 +227,6 @@ export declare class BuiltIns {
      * @see {@link builtInMemory}
      */
     emptyBuiltInMemory: BuiltInMemory;
-    set(identifier: Identifier, definition: IdentifierDefinition[], includeInEmptyMemory: boolean | undefined): void;
+    set(identifier: BrandedIdentifier, definition: IdentifierDefinition[], includeInEmptyMemory: boolean | undefined): void;
 }
 export {};

package/dataflow/environments/built-in.js

@@ -38,6 +38,7 @@ const built_in_try_catch_1 = require("../internal/process/functions/call/built-i
 const built_in_register_hook_1 = require("../internal/process/functions/call/built-in/built-in-register-hook");
 const built_in_local_1 = require("../internal/process/functions/call/built-in/built-in-local");
 const built_in_s_three_dispatch_1 = require("../internal/process/functions/call/built-in/built-in-s-three-dispatch");
+const built_in_recall_1 = require("../internal/process/functions/call/built-in/built-in-recall");
 /**
  * Generate a built-in id for the given name
  */
@@ -81,7 +82,7 @@ function defaultBuiltInProcessor(name, args, rootId, data, { returnsNthArgument,
             (0, unknown_side_effect_1.handleUnknownSideEffect)(res.graph, res.environment, rootId, hasUnknownSideEffects);
         }
     }
-    const fnCallNames = treatAsFnCall?.[name.content];
+    const fnCallNames = treatAsFnCall?.[identifier_1.Identifier.getName(name.content)];
     if (fnCallNames) {
         for (const arg of args) {
             if (arg !== r_function_call_1.EmptyArgument && arg.value && fnCallNames.includes(arg.name?.content)) {
@@ -158,6 +159,10 @@ var BuiltInProcName;
     BuiltInProcName["Pipe"] = "builtin:pipe";
     /** for `quote`, and other substituting calls, see {@link processQuote} */
     BuiltInProcName["Quote"] = "builtin:quote";
+    /**
+     * for `recall` calls, see {@link processRecall}
+     */
+    BuiltInProcName["Recall"] = "builtin:recall";
     /** for `on.exìt` and other hooks, see {@link processRegisterHook} */
     BuiltInProcName["RegisterHook"] = "builtin:register-hook";
     /** for `repeat` loops, see {@link processRepeatLoop} */
@@ -206,6 +211,7 @@ exports.BuiltInProcessorMapper = {
     [BuiltInProcName.Local]: built_in_local_1.processLocal,
     [BuiltInProcName.Pipe]: built_in_pipe_1.processPipe,
     [BuiltInProcName.Quote]: built_in_quote_1.processQuote,
+    [BuiltInProcName.Recall]: built_in_recall_1.processRecall,
     [BuiltInProcName.RegisterHook]: built_in_register_hook_1.processRegisterHook,
     [BuiltInProcName.RepeatLoop]: built_in_repeat_loop_1.processRepeatLoop,
     [BuiltInProcName.Replacement]: built_in_replacement_1.processReplacementFunction,
@@ -230,7 +236,8 @@ class BuiltIns {
      */
     registerBuiltInConstant({ names, value, assumePrimitive }) {
         for (const name of names) {
-            const id = builtInId(name);
+            const n = identifier_1.Identifier.getName(name);
+            const id = builtInId(n);
             const d = [{
                     type: identifier_1.ReferenceType.BuiltInConstant,
                     definedAt: id,
@@ -239,7 +246,7 @@ class BuiltIns {
                     name,
                     nodeId: id
                 }];
-            this.set(name, d, assumePrimitive);
+            this.set(n, d, assumePrimitive);
         }
     }
     /**
@@ -250,7 +257,8 @@ class BuiltIns {
         const mappedProcessor = exports.BuiltInProcessorMapper[processor];
         (0, assert_1.guard)(mappedProcessor !== undefined, () => `Processor for ${processor} is undefined! Please pass a valid builtin name ${JSON.stringify(Object.keys(exports.BuiltInProcessorMapper))}!`);
         for (const name of names) {
-            const id = builtInId(name);
+            const n = identifier_1.Identifier.getName(name);
+            const id = builtInId(n);
             const d = [{
                     type: identifier_1.ReferenceType.BuiltInFunction,
                     definedAt: id,
@@ -261,7 +269,7 @@ class BuiltIns {
                     name,
                     nodeId: id
                 }];
-            this.set(name, d, assumePrimitive);
+            this.set(n, d, assumePrimitive);
         }
     }
     /**
@@ -272,7 +280,7 @@ class BuiltIns {
         (0, assert_1.guard)(replacer !== undefined, () => `Processor for ${BuiltInProcName.Replacement} is undefined!`);
         for (const assignment of names) {
             for (const suffix of suffixes) {
-                const effectiveName = `${assignment}${suffix}`;
+                const effectiveName = `${identifier_1.Identifier.getName(assignment)}${suffix}`;
                 const id = builtInId(effectiveName);
                 const d = [{
                         type: identifier_1.ReferenceType.BuiltInFunction,
@@ -283,7 +291,7 @@ class BuiltIns {
                             assignmentOperator: suffix,
                             makeMaybe: true
                         },
-                        name: effectiveName,
+                        name: assignment,
                         cds: undefined,
                         nodeId: id
                     }];

package/dataflow/environments/default-builtin-config.d.ts

@@ -5,6 +5,7 @@ import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-i
 import { CascadeAction } from '../../queries/catalog/call-context-query/cascade-action';
 import { BuiltInProcName } from './built-in';
 import { KnownHooks } from '../hooks';
+import { Identifier } from './identifier';
 export declare const GgPlotCreate: readonly ["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"];
 export declare const TinyPlotCrate: readonly ["tinyplot", "plt"];
 export declare const GraphicsPlotCreate: string[];
@@ -383,7 +384,7 @@ export declare const DefaultBuiltinConfig: [{
     readonly assumePrimitive: false;
 }, {
     readonly type: "function";
-    readonly names: ["library", "require"];
+    readonly names: [Identifier, Identifier];
     readonly processor: BuiltInProcName.Library;
     readonly config: {};
     readonly assumePrimitive: false;
@@ -598,6 +599,14 @@ export declare const DefaultBuiltinConfig: [{
     readonly processor: BuiltInProcName.List;
     readonly config: {};
     readonly assumePrimitive: true;
+}, {
+    readonly type: "function";
+    readonly names: ["Recall"];
+    readonly processor: BuiltInProcName.Recall;
+    readonly config: {
+        readonly libFn: true;
+    };
+    readonly assumePrimitive: false;
 }, {
     readonly type: "function";
     readonly names: ["c"];

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

@@ -8,6 +8,7 @@ const cascade_action_1 = require("../../queries/catalog/call-context-query/casca
 const built_in_1 = require("./built-in");
 const unnamed_call_handling_1 = require("../internal/process/functions/call/unnamed-call-handling");
 const hooks_1 = require("../hooks");
+const identifier_1 = require("./identifier");
 exports.GgPlotCreate = [
     'ggplot', 'ggplotly', 'ggMarginal', 'ggcorrplot', 'ggseasonplot', 'ggdendrogram', 'qmap', 'qplot', 'quickplot', 'autoplot', 'grid.arrange',
     'fviz_pca_biplot', 'fviz_pca', 'fviz_pca_ind', 'fviz_pca_var', 'fviz_screeplot', 'fviz_mca_biplot', 'fviz_mca', 'fviz_mca_ind', 'fviz_mca_var', 'fviz_cluster', 'fviz_dend',
@@ -140,7 +141,7 @@ exports.DefaultBuiltinConfig = [
                 type: 'link-to-last-call',
                 ignoreIf: (source, graph) => {
                     /* map with add = true appends to an existing plot */
-                    return (exports.PlotFunctionsWithAddParam.has(source.name) && (0, identify_link_to_last_call_relation_1.getValueOfArgument)(graph, source, {
+                    return (exports.PlotFunctionsWithAddParam.has(identifier_1.Identifier.getName(source.name)) && (0, identify_link_to_last_call_relation_1.getValueOfArgument)(graph, source, {
                         index: -1,
                         name: 'add'
                     }, [type_1.RType.Logical])?.content === true);
@@ -161,14 +162,14 @@ exports.DefaultBuiltinConfig = [
                 ignoreIf: (source, graph) => {
                     const sourceVertex = graph.getVertex(source);
                     /* map with add = true appends to an existing plot */
-                    return (exports.PlotFunctionsWithAddParam.has(sourceVertex.name ?? '') && (0, identify_link_to_last_call_relation_1.getValueOfArgument)(graph, sourceVertex, {
+                    return (exports.PlotFunctionsWithAddParam.has(identifier_1.Identifier.getName(sourceVertex.name)) && (0, identify_link_to_last_call_relation_1.getValueOfArgument)(graph, sourceVertex, {
                         index: -1,
                         name: 'add'
                     }, [type_1.RType.Logical])?.content !== true);
                 },
                 cascadeIf: (target, _, graph) => {
                     /* map with add = true appends to an existing plot */
-                    return target.name === 'map' ? ((0, identify_link_to_last_call_relation_1.getValueOfArgument)(graph, target, {
+                    return identifier_1.Identifier.getName(target.name) ? ((0, identify_link_to_last_call_relation_1.getValueOfArgument)(graph, target, {
                         index: 11,
                         name: 'add'
                     }, [type_1.RType.Logical])?.content === true ? cascade_action_1.CascadeAction.Continue : cascade_action_1.CascadeAction.Stop) : cascade_action_1.CascadeAction.Stop;
@@ -253,7 +254,7 @@ exports.DefaultBuiltinConfig = [
     { type: 'function', names: ['ifelse', 'fifelse', 'IfElse'], processor: built_in_1.BuiltInProcName.IfThenElse, config: { args: { cond: 'test', yes: 'yes', no: 'no' } }, assumePrimitive: true },
     { type: 'function', names: ['if_else'], processor: built_in_1.BuiltInProcName.IfThenElse, config: { args: { cond: 'condition', yes: 'true', no: 'false' } }, assumePrimitive: true },
     { type: 'function', names: ['get'], processor: built_in_1.BuiltInProcName.Get, config: {}, assumePrimitive: false },
-    { type: 'function', names: ['library', 'require'], processor: built_in_1.BuiltInProcName.Library, config: {}, assumePrimitive: false },
+    { type: 'function', names: [identifier_1.Identifier.make('library', 'base'), identifier_1.Identifier.make('require', 'base')], processor: built_in_1.BuiltInProcName.Library, config: {}, assumePrimitive: false },
     { type: 'function', names: ['<-', '='], processor: built_in_1.BuiltInProcName.Assignment, config: { canBeReplacement: true }, assumePrimitive: true },
     { type: 'function', names: [':='], processor: built_in_1.BuiltInProcName.Assignment, config: {}, assumePrimitive: true },
     { type: 'function', names: ['assign', 'setGeneric', 'setValidity'], processor: built_in_1.BuiltInProcName.Assignment, config: { targetVariable: true, mayHaveMoreArgs: true }, assumePrimitive: true },
@@ -278,6 +279,7 @@ exports.DefaultBuiltinConfig = [
     { type: 'function', names: ['interference'], processor: built_in_1.BuiltInProcName.Apply, config: { unquoteFunction: true, nameOfFunctionArgument: 'propensity_integrand', libFn: true }, assumePrimitive: false },
     { type: 'function', names: ['ddply'], processor: built_in_1.BuiltInProcName.Apply, config: { unquoteFunction: true, indexOfFunction: 2, nameOfFunctionArgument: '.fun', libFn: true }, assumePrimitive: false },
     { type: 'function', names: ['list'], processor: built_in_1.BuiltInProcName.List, config: {}, assumePrimitive: true },
+    { type: 'function', names: ['Recall'], processor: built_in_1.BuiltInProcName.Recall, config: { libFn: true }, assumePrimitive: false },
     { type: 'function', names: ['c'], processor: built_in_1.BuiltInProcName.Vector, config: {}, assumePrimitive: true, evalHandler: 'built-in:c' },
     {
         type: 'function',

package/dataflow/environments/define.d.ts

@@ -1,16 +1,9 @@
 import type { REnvironmentInformation } from './environment';
-import type { Identifier, IdentifierDefinition, InGraphIdentifierDefinition } from './identifier';
-import type { FlowrConfigOptions } from '../../config';
+import { Identifier, type IdentifierDefinition } from './identifier';
 /**
- * assumes: existing is not undefined, the overwrite has indices
- */
-export declare function mergeDefinitionsForPointer(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.
- * @see {@link Environment#define}      - for details on how (local) definitions are handled.
- * @see {@link Environment#defineSuper} - for details on how (super) definitions are handled.
+ * Define an identifier in the environment, possibly as a super assignment.
+ * This recalculates the level
  */
 export declare function define(definition: IdentifierDefinition & {
     name: Identifier;
-}, superAssign: boolean | undefined, { level, current }: REnvironmentInformation, config: FlowrConfigOptions): REnvironmentInformation;
+}, superAssign: boolean | undefined, { level, current }: REnvironmentInformation): REnvironmentInformation;

package/dataflow/environments/define.js

@@ -1,105 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeDefinitionsForPointer = mergeDefinitionsForPointer;
 exports.define = define;
-const assert_1 = require("../../util/assert");
-const vertex_1 = require("../graph/vertex");
+const identifier_1 = require("./identifier");
 /**
- * assumes: existing is not undefined, the overwrite has indices
+ * Define an identifier in the environment, possibly as a super assignment.
+ * This recalculates the level
  */
-function mergeDefinitionsForPointer(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.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) {
-            // 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) {
-                const obj = {
-                    ...existingDef,
-                    indicesCollection: newIndicesCollection,
-                };
-                const objHash = JSON.stringify(obj);
-                if (!hasCache.has(objHash)) {
-                    newExistingDefs.push(obj);
-                    hasCache.add(objHash);
-                }
-            }
-        }
-    }
-    // store changed existing definitions and add new one
-    return [...newExistingDefs, definition];
-}
-function overwriteContainerIndices(existingIndices, overwriteIndex) {
-    const newIndicesCollection = [];
-    for (const indices of existingIndices) {
-        let newIndices;
-        // When overwrite index is container itself, then only overwrite sub-index
-        if ((0, vertex_1.isParentContainerIndex)(overwriteIndex)) {
-            newIndices = [];
-            for (const index of indices.indices) {
-                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) {
-                        newSubIndices = overwriteContainerIndices(newSubIndices, overwriteSubIndex);
-                    }
-                    if (newSubIndices.length > 0) {
-                        newIndices.push({
-                            ...index,
-                            subIndices: newSubIndices,
-                        });
-                    }
-                }
-                if (!(0, vertex_1.isSameIndex)(index, overwriteIndex) || !(0, vertex_1.isParentContainerIndex)(index)) {
-                    newIndices.push(index);
-                }
-            }
-        }
-        else if (indices.isContainer) {
-            // If indices are not a single, e.g., a list, take the whole definition
-            newIndices = indices.indices;
-        }
-        else {
-            // Filter existing indices with the same name
-            newIndices = indices.indices.filter(def => !(0, vertex_1.isSameIndex)(def, overwriteIndex));
-        }
-        if (indices.isContainer || newIndices.length > 0) {
-            newIndicesCollection.push({
-                ...indices,
-                indices: newIndices,
-            });
-        }
-    }
-    return newIndicesCollection;
-}
-/**
- * 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.
- * @see {@link Environment#define}      - for details on how (local) definitions are handled.
- * @see {@link Environment#defineSuper} - for details on how (super) definitions are handled.
- */
-function define(definition, superAssign, { level, current }, config) {
+function define(definition, superAssign, { level, current }) {
+    const newEnv = superAssign ? current.defineSuper(definition) : current.define(definition);
     return {
-        level,
-        current: superAssign ? current.defineSuper(definition) : current.define(definition, config),
+        level: identifier_1.Identifier.getNamespace(definition.name) === undefined ? level : recalculateLevel(newEnv),
+        current: newEnv,
     };
 }
+function recalculateLevel(env) {
+    let level = 0;
+    let current = env;
+    while (current.parent && !current.parent.builtInEnv) {
+        level++;
+        current = current.parent;
+    }
+    return level;
+}
 //# sourceMappingURL=define.js.map