@eagleoutice/flowr 2.8.15 → 2.9.1

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,10 +254,10 @@ 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 },
+    { type: 'function', names: ['assign', 'setValidity'], processor: built_in_1.BuiltInProcName.Assignment, config: { targetVariable: true, mayHaveMoreArgs: true }, assumePrimitive: true },
     { type: 'function', names: ['setMethod'], processor: built_in_1.BuiltInProcName.AssignmentLike, config: { targetVariable: true, canBeReplacement: false, target: { idx: 0, name: 'f' }, source: { idx: 2, name: 'definition' } }, assumePrimitive: true },
     { type: 'function', names: ['delayedAssign'], processor: built_in_1.BuiltInProcName.Assignment, config: { quoteSource: true, targetVariable: true }, assumePrimitive: true },
     { type: 'function', names: ['<<-'], processor: built_in_1.BuiltInProcName.Assignment, config: { superAssignment: true, canBeReplacement: true }, assumePrimitive: true },
@@ -272,12 +273,16 @@ exports.DefaultBuiltinConfig = [
     { type: 'function', names: ['repeat'], processor: built_in_1.BuiltInProcName.RepeatLoop, config: {}, assumePrimitive: true },
     { type: 'function', names: ['while'], processor: built_in_1.BuiltInProcName.WhileLoop, config: {}, assumePrimitive: true },
     { type: 'function', names: ['do.call'], processor: built_in_1.BuiltInProcName.Apply, config: { indexOfFunction: 0, unquoteFunction: true }, assumePrimitive: true },
-    { type: 'function', names: ['NextMethod'], processor: built_in_1.BuiltInProcName.Apply, config: { indexOfFunction: 0, unquoteFunction: true, resolveInEnvironment: 'global' }, assumePrimitive: true },
     { type: 'function', names: ['UseMethod'], processor: built_in_1.BuiltInProcName.S3Dispatch, config: { args: { generic: 'generic', object: 'object' } }, assumePrimitive: true },
+    { type: 'function', names: ['NextMethod'], processor: built_in_1.BuiltInProcName.S3Dispatch, config: { args: { generic: 'generic', object: 'object' }, inferFromClosure: true }, assumePrimitive: true },
+    { type: 'function', names: ['new_generic'], processor: built_in_1.BuiltInProcName.S7NewGeneric, config: { args: { name: 'name', dispatchArg: 'dispatch_args', fun: 'fun' } }, assumePrimitive: true },
+    { type: 'function', names: ['setGeneric'], processor: built_in_1.BuiltInProcName.S7NewGeneric, config: { args: { name: 'name', dispatchArg: undefined, fun: 'fun' } }, assumePrimitive: true },
+    { type: 'function', names: ['S7_dispatch'], processor: built_in_1.BuiltInProcName.S7Dispatch, config: { libFn: true }, assumePrimitive: true },
     { type: 'function', names: ['.Primitive', '.Internal'], processor: built_in_1.BuiltInProcName.Apply, config: { indexOfFunction: 0, unquoteFunction: true, resolveInEnvironment: 'global' }, assumePrimitive: true },
     { 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',
@@ -339,6 +344,15 @@ exports.DefaultBuiltinConfig = [
             readIndices: true
         }
     },
+    {
+        type: 'replacement',
+        suffixes: ['<-', '<<-'],
+        names: ['method'],
+        config: {
+            readIndices: true,
+            constructName: 's7'
+        }
+    },
     {
         type: 'replacement',
         suffixes: ['<-', '<<-'],

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

package/dataflow/environments/diff.js

@@ -6,6 +6,7 @@ exports.diffEnvironmentInformation = diffEnvironmentInformation;
 const diff_1 = require("../../util/diff");
 const environment_1 = require("./environment");
 const json_1 = require("../../util/json");
+const identifier_1 = require("./identifier");
 const info_1 = require("../info");
 /**
  * Compares two identifier references and reports differences.
@@ -18,7 +19,7 @@ function diffIdentifierReferences(a, b, info) {
         return;
     }
     if (a.name !== b.name) {
-        info.report.addComment(`${info.position}Different identifier names: ${info.leftname}: ${a.name} vs. ${info.rightname}: ${b.name}`);
+        info.report.addComment(`${info.position}Different identifier names: ${info.leftname}: ${a.name ? identifier_1.Identifier.toString(a.name) : 'undefined'} vs. ${info.rightname}: ${b.name ? identifier_1.Identifier.toString(b.name) : 'undefined'}`);
     }
     if (a.nodeId !== b.nodeId) {
         info.report.addComment(`${info.position}Different nodeIds: ${info.leftname}: ${a.nodeId} vs. ${info.rightname}: ${b.nodeId}`);
@@ -39,7 +40,7 @@ function diffMemory(a, b, info) {
             const aVal = sorted[i];
             const bVal = sorted2[i];
             if (aVal.name !== bVal.name) {
-                info.report.addComment(`${info.position}Different names for ${key}. ${info.leftname}: ${aVal.name} vs. ${info.rightname}: ${bVal.name}`);
+                info.report.addComment(`${info.position}Different names for ${key}. ${info.leftname}: ${aVal.name ? identifier_1.Identifier.toString(aVal.name) : 'undefined'} vs. ${info.rightname}: ${bVal.name ? identifier_1.Identifier.toString(bVal.name) : undefined}`);
             }
             if (aVal.nodeId !== bVal.nodeId) {
                 info.report.addComment(`${info.position}Different ids for ${key}. ${info.leftname}: ${aVal.nodeId} vs. ${info.rightname}: ${bVal.nodeId}`);

package/dataflow/environments/environment.d.ts

@@ -1,7 +1,7 @@
 import type { BuiltInMemory } from './built-in';
-import type { Identifier, IdentifierDefinition } from './identifier';
+import type { IdentifierDefinition } from './identifier';
+import { Identifier } from './identifier';
 import type { ControlDependency } from '../info';
-import type { FlowrConfigOptions } from '../../config';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 /** A single entry/scope within an {@link REnvironmentInformation} */
 export interface IEnvironment {
@@ -30,11 +30,22 @@ export declare function isDefaultBuiltInEnvironment(obj: unknown): boolean;
 /** @see REnvironmentInformation */
 export declare class Environment implements IEnvironment {
     readonly id: number;
+    /** Optional name for namespaced/non-anonymous environments, please only set if you know what you are doing */
+    n?: string;
+    /** if created by a closure, the node id of that closure */
+    private c?;
     parent: Environment;
     memory: BuiltInMemory;
-    cache?: BuiltInMemory;
+    cache?: Map<Identifier, IdentifierDefinition[]>;
     builtInEnv?: true;
     constructor(parent: Environment, isBuiltInDefault?: true | undefined);
+    /** please only use if you know what you are doing */
+    setClosureNodeId(nodeId: NodeId): void;
+    /**
+     * Provides the closure linked to this environment.
+     * This is of importance if, for example, if you want to know the function definition associated with this environment.
+     */
+    get closure(): NodeId | undefined;
     /**
      * Create a deep clone of this environment.
      * @param recurseParents     - Whether to also clone parent environments
@@ -43,11 +54,11 @@ export declare class Environment implements IEnvironment {
     /**
      * Define a new identifier definition within this environment.
      * @param definition  - The definition to add.
-     * @param config      - The flowr configuration options.
      */
     define(definition: IdentifierDefinition & {
         name: Identifier;
-    }, { solver: { pointerTracking } }: FlowrConfigOptions): Environment;
+    }): Environment;
+    private defineInNamespace;
     defineSuper(definition: IdentifierDefinition & {
         name: Identifier;
     }): Environment;
@@ -62,7 +73,7 @@ export declare class Environment implements IEnvironment {
      * This always recurses parents.
      */
     append(other: Environment | undefined): Environment;
-    remove(name: Identifier): this;
+    remove(id: Identifier): this;
     removeAll(names: readonly {
         name: Identifier;
     }[]): Environment;

package/dataflow/environments/environment.js

@@ -9,10 +9,11 @@ exports.builtInEnvJsonReplacer = builtInEnvJsonReplacer;
  * @module
  */
 const json_1 = require("../../util/json");
+const identifier_1 = require("./identifier");
 const assert_1 = require("../../util/assert");
 const info_1 = require("../info");
-const define_1 = require("./define");
 const append_1 = require("./append");
+const log_1 = require("../../util/log");
 /**
  * Please use this function only if you do not know the object type.
  * Otherwise, rely on {@link IEnvironment#builtInEnv}
@@ -24,6 +25,10 @@ let environmentIdCounter = 1; // Zero is reserved for built-in environment
 /** @see REnvironmentInformation */
 class Environment {
     id;
+    /** Optional name for namespaced/non-anonymous environments, please only set if you know what you are doing */
+    n;
+    /** if created by a closure, the node id of that closure */
+    c;
     parent;
     memory;
     cache;
@@ -37,6 +42,17 @@ class Environment {
             this.builtInEnv = isBuiltInDefault;
         }
     }
+    /** please only use if you know what you are doing */
+    setClosureNodeId(nodeId) {
+        this.c = nodeId;
+    }
+    /**
+     * Provides the closure linked to this environment.
+     * This is of importance if, for example, if you want to know the function definition associated with this environment.
+     */
+    get closure() {
+        return this.c;
+    }
     /**
      * Create a deep clone of this environment.
      * @param recurseParents     - Whether to also clone parent environments
@@ -47,6 +63,8 @@ class Environment {
         }
         const parent = recurseParents ? this.parent.clone(recurseParents) : this.parent;
         const clone = new Environment(parent, this.builtInEnv);
+        clone.c = this.c;
+        clone.n = this.n;
         clone.memory = new Map(this.memory.entries()
             .map(([k, v]) => [k,
             v.map(s => ({
@@ -59,29 +77,23 @@ class Environment {
     /**
      * Define a new identifier definition within this environment.
      * @param definition  - The definition to add.
-     * @param config      - The flowr configuration options.
      */
-    define(definition, { solver: { pointerTracking } }) {
-        const { name } = definition;
+    define(definition) {
+        const [name, ns] = identifier_1.Identifier.toArray(definition.name);
+        if (ns !== undefined && this.n !== ns) {
+            return this.defineInNamespace(definition, ns);
+        }
         const newEnvironment = this.clone(false);
         // When there are defined indices, merge the definitions
-        if (definition.cds === undefined && !pointerTracking) {
+        if (definition.cds === undefined) {
             newEnvironment.memory.set(name, [definition]);
         }
         else {
             const existing = newEnvironment.memory.get(name);
             const inGraphDefinition = definition;
-            if (pointerTracking &&
-                existing !== undefined &&
+            if (existing !== undefined &&
                 inGraphDefinition.cds === undefined) {
-                if (inGraphDefinition.indicesCollection !== undefined) {
-                    const defs = (0, define_1.mergeDefinitionsForPointer)(existing, inGraphDefinition);
-                    newEnvironment.memory.set(name, defs);
-                }
-                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);
-                }
+                newEnvironment.memory.set(name, [inGraphDefinition]);
             }
             else if (existing === undefined || definition.cds === undefined) {
                 newEnvironment.memory.set(name, [definition]);
@@ -92,9 +104,40 @@ class Environment {
         }
         return newEnvironment;
     }
+    defineInNamespace(definition, ns) {
+        if (this.n === ns) {
+            return this.define(definition);
+        }
+        // navigate to parent until either before built-in or matching namespace
+        const newEnvironment = this.clone(false);
+        const current = newEnvironment;
+        do {
+            if (current.n === ns) {
+                current.define(definition);
+                return newEnvironment;
+            }
+            else if (current.parent && !current.parent.builtInEnv) {
+                // clone parent
+                current.parent = current.parent.clone(false);
+            }
+            else {
+                break;
+            }
+        } while (current.n !== ns);
+        // we did not find the namespace, so we inject a new environment here
+        log_1.log.warn(`Defining ${identifier_1.Identifier.getName(definition.name)} in namespace ${ns}, which did not exist yet in the environment chain => create (r should fail or we miss attachment).`);
+        const env = new Environment(current.parent);
+        env.n = ns;
+        current.parent = env.define(definition);
+        return newEnvironment;
+    }
     defineSuper(definition) {
-        const { name } = definition;
-        const newEnvironment = this.clone(true);
+        const [name, ns] = identifier_1.Identifier.toArray(definition.name);
+        const newEnvironment = this.clone(false);
+        if (ns !== undefined && this.n !== ns) {
+            newEnvironment.parent = newEnvironment.parent.defineInNamespace(definition, ns);
+            return newEnvironment;
+        }
         let current = newEnvironment;
         let last = undefined;
         let found = false;
@@ -105,6 +148,7 @@ class Environment {
                 break;
             }
             last = current;
+            current.parent = current.parent.clone(false);
             current = current.parent;
         } while (!current.builtInEnv);
         if (!found) {
@@ -152,6 +196,8 @@ class Environment {
             }
         }
         const out = new Environment(this.parent.overwrite(other.parent, applyCds));
+        out.c = this.c;
+        out.n = this.n;
         out.memory = map;
         return out;
     }
@@ -177,10 +223,15 @@ class Environment {
         out.memory = map;
         return out;
     }
-    remove(name) {
+    remove(id) {
         if (this.builtInEnv) {
             return this;
         }
+        const [name, ns] = identifier_1.Identifier.toArray(id);
+        if (ns !== undefined && this.n !== ns) {
+            this.parent.remove(id);
+            return this;
+        }
         const definition = this.memory.get(name);
         let cont = true;
         if (definition !== undefined) {

package/dataflow/environments/identifier.d.ts

@@ -1,10 +1,100 @@
 import type { BuiltInIdentifierConstant, BuiltInIdentifierDefinition } from './built-in';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { ControlDependency } from '../info';
-import type { ContainerIndicesCollection } from '../graph/vertex';
-export type Identifier = string & {
+/** this is just a safe-guard type to prevent mixing up branded identifiers with normal strings */
+export type BrandedIdentifier = string & {
     __brand?: 'identifier';
 };
+/** this is just a safe-guard type to prevent mixing up branded namespaces with normal strings */
+export type BrandedNamespace = string & {
+    __brand?: 'namespace';
+};
+/**
+ * Refers to an identifier by its name.
+ * This can either be a simple name like `a` or a namespaced name like `pkg::a` (stored as ['a', 'pkg']).
+ * By storing the namespace second, you can easily access the actual name via `id[0]`.
+ * This represents the fundamental way to represent binding names in R.
+ * @see {@link Identifier.getName} - to get the name part
+ * @see {@link Identifier.getNamespace} - to get the namespace part
+ * @see {@link Identifier.accessesInternal} - to check if the identifier accesses internal objects (`:::`)
+ * @see {@link Identifier.toString} - to convert the identifier to a string representation
+ */
+export type Identifier = BrandedIdentifier | [id: BrandedIdentifier, namespace: BrandedNamespace, internal?: boolean];
+/**
+ * Helper functions to work with {@link Identifier|identifiers}.
+ * Use {@link Identifier.matches} to check if two identifiers match according to R's scoping rules!
+ * @example
+ * ```ts
+ * const id1 = Identifier.make('a', 'pkg');
+ * const id2 = Identifier.parse('pkg::a');
+ * const id3 = Identifier.parse('a');
+ * Identifier.matches(id1, id2); // true
+ * Identifier.matches(id3, id2); // true, as id3 has no namespace
+ * ```
+ */
+export declare const Identifier: {
+    /**
+     * Create an identifier from its name and optional namespace.
+     * Please note that for `internal` to count, a namespace must be provided!
+     */
+    readonly make: (this: void, name: BrandedIdentifier, namespace?: BrandedNamespace, internal?: boolean) => Identifier;
+    /**
+     * Parse an identifier from its string representation,
+     * Please note, that in R if one writes `"pkg::a"` this refers to a symbol named `pkg::a` and NOT to the namespaced identifier `a` in package `pkg`.
+     * In this scenario, see {@link Identifier.make} instead.
+     */
+    readonly parse: (this: void, str: string) => Identifier;
+    /**
+     * Get the name part of the identifier
+     */
+    readonly getName: (this: void, id: Identifier) => BrandedIdentifier;
+    /**
+     * Get the namespace part of the identifier, undefined if there is none
+     */
+    readonly getNamespace: (this: void, id: Identifier) => BrandedNamespace | undefined;
+    /**
+     * Check if the identifier accesses internal objects (`:::`)
+     */
+    readonly accessesInternal: (this: void, id: Identifier) => boolean | undefined;
+    /**
+     * Convert the identifier to a **valid R** string representation,
+     * this will properly quote namespaces that contain `::` to avoid confusion.
+     * @example
+     * ```ts
+     * Identifier.toString('a') // 'a'
+     * Identifier.toString(['a', 'pkg']) // 'pkg::a'
+     * Identifier.toString(['a', 'pkg:::internal', true]) // '"pkg:::internal":::a'
+     * ```
+     */
+    readonly toString: (this: void, id: Identifier) => string;
+    /**
+     * Check if two identifiers match.
+     * This differs from eq!
+     * If the first identifier is not namespaced, it will match any namespace!
+     * If we search for S3 methods (s3=true), the target may have an additional suffix after a dot.
+     * If the first identifier is internal, it will match any target (internal or not).
+     */
+    readonly matches: (this: void, id: Identifier, target: Identifier, s3?: boolean) => boolean;
+    /** Special identifier for the `...` argument */
+    readonly dotdotdot: (this: void) => BrandedIdentifier;
+    /**
+     * Check if the identifier is the special `...` argument / or one of its accesses like `..1`, `..2`, etc.
+     * This always returns false for namespaced identifiers.
+     */
+    readonly isDotDotDotAccess: (this: void, id: Identifier) => boolean;
+    /**
+     * Functor over the name of the identifier
+     */
+    readonly mapName: (this: void, id: Identifier, fn: (name: BrandedIdentifier) => BrandedIdentifier) => Identifier;
+    /**
+     * Functor over the namespace of the identifier
+     */
+    readonly mapNamespace: (this: void, id: Identifier, fn: (ns: BrandedNamespace) => BrandedNamespace) => Identifier;
+    /**
+     * Convert the identifier to its array representation
+     */
+    readonly toArray: (this: void, id: Identifier) => [BrandedIdentifier, BrandedNamespace | undefined, boolean | undefined];
+};
 /**
  * Each reference has exactly one reference type, stored as the respective number.
  * However, when checking, we may want to allow for one of several types,
@@ -35,7 +125,9 @@ export declare enum ReferenceType {
     /** The identifier is defined by a built-in function */
     BuiltInFunction = 128,
     /** Prefix to identify S3 methods, use this, to for example dispatch a call to `f` which will then link to `f.*` */
-    S3MethodPrefix = 256
+    S3MethodPrefix = 256,
+    /** Prefix to identify S7 methods, use this, to for example dispatch a call to `f` which will then link to `f<7>*` */
+    S7MethodPrefix = 512
 }
 /** Reverse mapping of the reference types so you can get the name from the bitmask (useful for debugging) */
 export declare const ReferenceTypeReverseMapping: Map<ReferenceType, string>;
@@ -101,10 +193,6 @@ export interface InGraphIdentifierDefinition extends IdentifierReference {
      * For example, in `x <- 3; y <- x`, the definition of `y` will have the value `3` in its value set
      */
     readonly value?: NodeId[];
-    /**
-     * this attribute links a definition to indices (pointer links) it may be affected by or related to
-     */
-    indicesCollection?: ContainerIndicesCollection;
 }
 /**
  * Stores the definition of an identifier within an {@link IEnvironment}.