@eagleoutice/flowr 2.1.9 → 2.1.11

package/README.md

@@ -47,6 +47,9 @@ We welcome every contribution! Please check out the [contributing guidelines](ht
       <td align="center" valign="top" width="14.28%"><a href="https://github.com/Core5563"><img src="https://avatars.githubusercontent.com/u/140061253?v=4?s=100" width="100px;" alt="Core5563"/><br /><sub><b>Core5563</b></sub></a><br /><a href="https://github.com/flowr-analysis/flowr/commits?author=Core5563" title="Code">💻</a> <a href="https://github.com/flowr-analysis/flowr/commits?author=Core5563" title="Tests">⚠️</a></td>
       <td align="center" valign="top" width="14.28%"><a href="https://github.com/Ehcsan"><img src="https://avatars.githubusercontent.com/u/68707578?v=4?s=100" width="100px;" alt="Ehcsan"/><br /><sub><b>Ehcsan</b></sub></a><br /><a href="https://github.com/flowr-analysis/flowr/commits?author=Ehcsan" title="Code">💻</a> <a href="https://github.com/flowr-analysis/flowr/commits?author=Ehcsan" title="Tests">⚠️</a></td>
     </tr>
+    <tr>
+      <td align="center" valign="top" width="14.28%"><a href="https://github.com/Slartibartfass2"><img src="https://avatars.githubusercontent.com/u/40503329?v=4?s=100" width="100px;" alt="Felix Schlegel"/><br /><sub><b>Felix Schlegel</b></sub></a><br /><a href="https://github.com/flowr-analysis/flowr/commits?author=Slartibartfass2" title="Code">💻</a> <a href="https://github.com/flowr-analysis/flowr/commits?author=Slartibartfass2" title="Tests">⚠️</a></td>
+    </tr>
   </tbody>
   <tfoot>
     <tr>

package/cli/flowr.js

@@ -21,6 +21,7 @@ const core_1 = require("./repl/core");
 const repl_version_1 = require("./repl/commands/repl-version");
 const print_version_1 = require("./repl/print-version");
 const flowr_main_options_1 = require("./flowr-main-options");
+const fs_1 = __importDefault(require("fs"));
 exports.toolName = 'flowr';
 exports.optionHelp = [
     {
@@ -59,6 +60,13 @@ if (options['config-json']) {
     }
 }
 if (!usedConfig) {
+    if (options['config-file']) {
+        // validate it exists
+        if (!fs_1.default.existsSync(options['config-file'])) {
+            log_1.log.error(`Config file '${options['config-file']}' does not exist`);
+            process.exit(1);
+        }
+    }
     (0, config_1.setConfigFile)(options['config-file'] ?? flowr_main_options_1.defaultConfigFile, undefined, true);
 }
 function retrieveShell() {

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

@@ -21,8 +21,10 @@ function printHelp(output) {
     output.stdout('The query is an array of query objects to represent multiple queries. Each query object may have the following properties:');
     output.stdout((0, schema_1.describeSchema)((0, query_1.AnyQuerySchema)(), output.formatter));
     output.stdout(`\n\nThe example ${(0, ansi_1.italic)(':query "[{\\"type\\": \\"call-context\\", \\"callName\\": \\"mean\\" }]" mean(1:10)', output.formatter)} would return the call context of the mean function.`);
-    output.stdout('As a convenience, we interpret any (non-help) string not starting with \'[\' as a regex for the simple call-context query.');
+    output.stdout('As a convenience, we interpret any (non-help, non-@) string not starting with \'[\' as a regex for the simple call-context query.');
     output.stdout(`Hence, ${(0, ansi_1.italic)(':query "mean" mean(1:10)', output.formatter)} is equivalent to the above example.`);
+    output.stdout(`Similarly, '@<type>' is interpreted as a query of the given type.`);
+    output.stdout(`With this, ${(0, ansi_1.italic)(':query @config', output.formatter)} prints the result of the config query.`);
 }
 async function processQueryArgs(line, shell, output) {
     const args = (0, args_1.splitAtEscapeSensitive)(line);
@@ -36,7 +38,16 @@ async function processQueryArgs(line, shell, output) {
         return;
     }
     let parsedQuery = [];
-    if (query.startsWith('[')) {
+    if (query.startsWith('@')) {
+        parsedQuery = [{ type: query.slice(1) }];
+        const validationResult = (0, query_1.QueriesSchema)().validate(parsedQuery);
+        if (validationResult.error) {
+            output.stderr(`Invalid query: ${validationResult.error.message}`);
+            printHelp(output);
+            return;
+        }
+    }
+    else if (query.startsWith('[')) {
         parsedQuery = JSON.parse(query);
         const validationResult = (0, query_1.QueriesSchema)().validate(parsedQuery);
         if (validationResult.error) {

package/config.d.ts

@@ -1,6 +1,14 @@
 import type { MergeableRecord } from './util/objects';
 import Joi from 'joi';
 import type { BuiltInDefinitions } from './dataflow/environments/built-in-config';
+export declare enum VariableResolve {
+    /** Don't resolve constants at all */
+    Disabled = "disabled",
+    /** Use alias tracking to resolve */
+    Alias = "alias",
+    /** Only resolve directly assigned builtin constants */
+    Builtin = "builtin"
+}
 export interface FlowrConfigOptions extends MergeableRecord {
     /**
      * Whether source calls should be ignored, causing {@link processSourceCall}'s behavior to be skipped
@@ -23,6 +31,19 @@ export interface FlowrConfigOptions extends MergeableRecord {
             };
         };
     };
+    /** How to resolve constants, constraints, cells, ... */
+    readonly solver: {
+        /**
+         * How to resolve variables and their values
+         */
+        readonly variables: VariableResolve;
+        /**
+         * Whether to track pointers in the dataflow graph,
+         * if not, the graph will be over-approximated wrt.
+         * containers and accesses
+         */
+        readonly pointerTracking: boolean;
+    };
 }
 export declare const defaultConfigOptions: FlowrConfigOptions;
 export declare const flowrConfigFileSchema: Joi.ObjectSchema<any>;

package/config.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.flowrConfigFileSchema = exports.defaultConfigOptions = void 0;
+exports.flowrConfigFileSchema = exports.defaultConfigOptions = exports.VariableResolve = void 0;
 exports.setConfigFile = setConfigFile;
 exports.parseConfig = parseConfig;
 exports.setConfig = setConfig;
@@ -14,6 +14,15 @@ const fs_1 = __importDefault(require("fs"));
 const log_1 = require("./util/log");
 const files_1 = require("./util/files");
 const joi_1 = __importDefault(require("joi"));
+var VariableResolve;
+(function (VariableResolve) {
+    /** Don't resolve constants at all */
+    VariableResolve["Disabled"] = "disabled";
+    /** Use alias tracking to resolve */
+    VariableResolve["Alias"] = "alias";
+    /** Only resolve directly assigned builtin constants */
+    VariableResolve["Builtin"] = "builtin";
+})(VariableResolve || (exports.VariableResolve = VariableResolve = {}));
 exports.defaultConfigOptions = {
     ignoreSourceCalls: false,
     rPath: undefined,
@@ -24,6 +33,10 @@ exports.defaultConfigOptions = {
                 definitions: []
             }
         }
+    },
+    solver: {
+        variables: VariableResolve.Alias,
+        pointerTracking: true
     }
 };
 exports.flowrConfigFileSchema = joi_1.default.object({
@@ -36,7 +49,11 @@ exports.flowrConfigFileSchema = joi_1.default.object({
                 definitions: joi_1.default.array().items(joi_1.default.object()).optional().description('The definitions to load/overwrite.')
             }).optional().description('Do you want to overwrite (parts) of the builtin definition?')
         }).optional().description('Semantics regarding the handlings of the environment.')
-    }).description('Configure language semantics and how flowR handles them.')
+    }).description('Configure language semantics and how flowR handles them.'),
+    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.')
+    }).description('How to resolve constants, constraints, cells, ...')
 }).description('The configuration file format for flowR.');
 // we don't load from a config file at all by default unless setConfigFile is called
 let configFile = undefined;

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

@@ -24,6 +24,7 @@ import { processSourceCall } from '../internal/process/functions/call/built-in/b
 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';
 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;
@@ -63,6 +64,7 @@ export declare const BuiltInProcessorMapper: {
     readonly 'builtin:repeat-loop': typeof processRepeatLoop;
     readonly 'builtin:while-loop': typeof processWhileLoop;
     readonly 'builtin:replacement': typeof processReplacementFunction;
+    readonly 'builtin:list': typeof processList;
 };
 export type BuiltInMappingName = keyof typeof BuiltInProcessorMapper;
 export type ConfigOfBuiltInMappingName<N extends BuiltInMappingName> = Parameters<typeof BuiltInProcessorMapper[N]>[4];

package/dataflow/environments/built-in.js

@@ -24,6 +24,7 @@ const built_in_source_1 = require("../internal/process/functions/call/built-in/b
 const built_in_apply_1 = require("../internal/process/functions/call/built-in/built-in-apply");
 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");
 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 });
@@ -88,6 +89,7 @@ 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,
 };
 exports.BuiltInMemory = new Map();
 exports.EmptyBuiltInMemory = new Map();

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

@@ -14,7 +14,7 @@ exports.DefaultBuiltinConfig = [
     {
         type: 'function',
         names: [
-            '~', '+', '-', '*', '/', '^', '!', '?', '**', '==', '!=', '>', '<', '>=', '<=', '%%', '%/%', '%*%', '%in%', ':', 'list',
+            '~', '+', '-', '*', '/', '^', '!', '?', '**', '==', '!=', '>', '<', '>=', '<=', '%%', '%/%', '%*%', '%in%', ':',
             'rep', 'seq', 'seq_len', 'seq_along', 'seq.int', 'gsub', 'which', 'class', 'dimnames', 'min', 'max',
             'intersect', 'subset', 'match', 'sqrt', 'abs', 'round', 'floor', 'ceiling', 'signif', 'trunc', 'log', 'log10', 'log2', 'sum', 'mean',
             'unique', 'paste', 'paste0', 'read.csv', 'stop', 'is.null', 'numeric', 'as.character', 'as.integer', 'as.logical', 'as.numeric', 'as.matrix',
@@ -29,7 +29,7 @@ exports.DefaultBuiltinConfig = [
     {
         type: 'function',
         names: [
-            'c', 't'
+            'c', 't', 'aperm' /* vector construction, concatenation, transpose function, permutation generation */
         ],
         processor: 'builtin:default',
         config: { readAllArguments: true },
@@ -113,6 +113,7 @@ 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: ['list'], processor: 'builtin:list', config: {}, assumePrimitive: true },
     {
         type: 'function',
         names: [

package/dataflow/environments/define.js

@@ -4,8 +4,15 @@ 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");
 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;
+    }
     // check if it is maybe or not
     if (existing === undefined || definition.controlDependencies === undefined) {
         newEnvironments.memory.set(name, [definition]);
@@ -14,6 +21,77 @@ function defInEnv(newEnvironments, name, definition) {
         existing.push(definition);
     }
 }
+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 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 = [];
+    for (const overwriteIndex of overwriteIndices) {
+        for (const existingDef of existingDefs) {
+            if (existingDef.indicesCollection === undefined) {
+                continue;
+            }
+            const newIndicesCollection = overwriteContainerIndices(existingDef.indicesCollection, overwriteIndex);
+            // if indices are now empty list, don't keep empty definition
+            if (newIndicesCollection.length > 0) {
+                newExistingDefs.push({
+                    ...existingDef,
+                    indicesCollection: newIndicesCollection,
+                });
+            }
+        }
+    }
+    // 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 (index.lexeme === overwriteIndex.lexeme && (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 (index.lexeme !== overwriteIndex.lexeme || !(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 => def.lexeme !== overwriteIndex.lexeme);
+        }
+        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.

package/dataflow/environments/identifier.d.ts

@@ -1,6 +1,7 @@
 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 & {
     __brand?: 'identifier';
 };
@@ -90,10 +91,18 @@ export interface IdentifierReference {
  *
  * @see {@link IdentifierReference}
  */
-interface InGraphIdentifierDefinition extends IdentifierReference {
+export interface InGraphIdentifierDefinition extends IdentifierReference {
     readonly type: InGraphReferenceType;
-    /** The assignment (or whatever, like `assign` function call) node which ultimately defined this identifier */
+    /**
+     * The assignment node which ultimately defined this identifier
+     * (the arrow operator for e.g. `x <- 3`, or `assign` call in `assign("x", 3)`)
+     */
     readonly definedAt: NodeId;
+    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}.
@@ -102,4 +111,3 @@ interface InGraphIdentifierDefinition extends IdentifierReference {
  * so the most important one for your day-to-day R script is the {@link InGraphIdentifierDefinition}.
  */
 export type IdentifierDefinition = InGraphIdentifierDefinition | BuiltInIdentifierDefinition | BuiltInIdentifierConstant;
-export {};

package/dataflow/environments/resolve-by-name.d.ts

@@ -2,6 +2,8 @@ import type { REnvironmentInformation } from './environment';
 import { Ternary } from '../../util/logic';
 import type { Identifier, IdentifierDefinition } from './identifier';
 import { ReferenceType } from './identifier';
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { DataflowGraph } from '../graph/graph';
 /**
  * Resolves a given identifier name to a list of its possible definition location using R scoping and resolving rules.
  *
@@ -9,12 +11,16 @@ import { ReferenceType } from './identifier';
  * @param environment  - The current environment used for name resolution
  * @param target       - The target (meta) type of the identifier to resolve
  *
- * @returns A list of possible definitions of the identifier (one if the definition location is exactly and always known), or `undefined` if the identifier is undefined in the current scope/with the current environment information.
+ * @returns A list of possible identifier definitions (one if the definition location is exactly and always known), or `undefined`
+ *          if the identifier is undefined in the current scope/with the current environment information.
  */
 export declare function resolveByName(name: Identifier, environment: REnvironmentInformation, target?: ReferenceType): IdentifierDefinition[] | undefined;
 export declare function resolvesToBuiltInConstant(name: Identifier | undefined, environment: REnvironmentInformation, wantedValue: unknown): Ternary;
-export interface ResolveResult<T = unknown> {
-    value: T;
-    from: ReferenceType;
-}
-export declare function resolveToConstants(name: Identifier | undefined, environment: REnvironmentInformation): ResolveResult[] | undefined;
+export declare function resolveToConstants(name: Identifier | undefined, environment: REnvironmentInformation): unknown[] | undefined;
+export declare function getAliases(sourceIds: readonly NodeId[], dataflow: DataflowGraph, environment: REnvironmentInformation): NodeId[] | undefined;
+export declare function resolveToValues(identifier: Identifier | undefined, environment: REnvironmentInformation, graph: DataflowGraph): unknown[] | undefined;
+/**
+ * Convenience function using the variable resolver as specified within the configuration file
+ * In the future we may want to have this set once at the start of the analysis
+ */
+export declare function resolveValueOfVariable(identifier: Identifier | undefined, environment: REnvironmentInformation, graph: DataflowGraph): unknown[] | undefined;

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

@@ -3,9 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveByName = resolveByName;
 exports.resolvesToBuiltInConstant = resolvesToBuiltInConstant;
 exports.resolveToConstants = resolveToConstants;
+exports.getAliases = getAliases;
+exports.resolveToValues = resolveToValues;
+exports.resolveValueOfVariable = resolveValueOfVariable;
 const environment_1 = require("./environment");
 const identifier_1 = require("./identifier");
 const info_1 = require("../info");
+const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
+const vertex_1 = require("../graph/vertex");
+const config_1 = require("../../config");
+const assert_1 = require("../../util/assert");
 const FunctionTargetTypes = identifier_1.ReferenceType.Function | identifier_1.ReferenceType.BuiltInFunction | identifier_1.ReferenceType.Unknown | identifier_1.ReferenceType.Argument | identifier_1.ReferenceType.Parameter;
 const VariableTargetTypes = identifier_1.ReferenceType.Variable | identifier_1.ReferenceType.Parameter | identifier_1.ReferenceType.Argument | identifier_1.ReferenceType.Unknown;
 const ConstantTargetTypes = identifier_1.ReferenceType.Constant | identifier_1.ReferenceType.BuiltInConstant | identifier_1.ReferenceType.Unknown;
@@ -28,7 +35,8 @@ const TargetTypePredicate = {
  * @param environment  - The current environment used for name resolution
  * @param target       - The target (meta) type of the identifier to resolve
  *
- * @returns A list of possible definitions of the identifier (one if the definition location is exactly and always known), or `undefined` if the identifier is undefined in the current scope/with the current environment information.
+ * @returns A list of possible identifier definitions (one if the definition location is exactly and always known), or `undefined`
+ *          if the identifier is undefined in the current scope/with the current environment information.
  */
 function resolveByName(name, environment, target = identifier_1.ReferenceType.Unknown) {
     let current = environment.current;
@@ -86,12 +94,103 @@ function resolveToConstants(name, environment) {
         return undefined;
     }
     const definitions = resolveByName(name, environment, identifier_1.ReferenceType.Constant);
-    if (definitions === undefined) {
+    return definitions?.map(def => def.value);
+}
+const AliasHandler = {
+    [vertex_1.VertexType.Value]: (sourceId) => [sourceId],
+    [vertex_1.VertexType.Use]: getUseAlias,
+    [vertex_1.VertexType.FunctionCall]: () => undefined,
+    [vertex_1.VertexType.FunctionDefinition]: () => undefined,
+    [vertex_1.VertexType.VariableDefinition]: () => undefined
+};
+function getUseAlias(sourceId, dataflow, environment) {
+    const definitions = [];
+    // Source is Symbol -> resolve definitions of symbol
+    const identifier = (0, node_id_1.recoverName)(sourceId, dataflow.idMap);
+    if (identifier === undefined) {
+        return undefined;
+    }
+    const defs = resolveByName(identifier, environment);
+    if (defs === undefined) {
         return undefined;
     }
-    return definitions.map(def => ({
-        value: def.value,
-        from: def.type
-    }));
+    for (const def of defs) {
+        // If one definition is not constant (or a variable aliasing a constant)
+        // we can't say for sure what value the source has
+        if (def.type === identifier_1.ReferenceType.Variable) {
+            if (def.value === undefined) {
+                return undefined;
+            }
+            definitions.push(...def.value);
+        }
+        else if (def.type === identifier_1.ReferenceType.Constant || def.type === identifier_1.ReferenceType.BuiltInConstant) {
+            definitions.push(def.nodeId);
+        }
+        else {
+            return undefined;
+        }
+    }
+    return definitions;
+}
+function getAliases(sourceIds, dataflow, environment) {
+    const definitions = new Set();
+    for (const sourceId of sourceIds) {
+        const info = dataflow.getVertex(sourceId);
+        if (info === undefined) {
+            return undefined;
+        }
+        const defs = AliasHandler[info.tag](sourceId, dataflow, environment);
+        for (const def of defs ?? []) {
+            definitions.add(def);
+        }
+    }
+    return [...definitions];
+}
+function resolveToValues(identifier, environment, graph) {
+    if (identifier === undefined) {
+        return undefined;
+    }
+    const defs = resolveByName(identifier, environment);
+    if (defs === undefined) {
+        return undefined;
+    }
+    const values = [];
+    for (const def of defs) {
+        if (def.type === identifier_1.ReferenceType.BuiltInConstant) {
+            values.push(def.value);
+        }
+        else if (def.type === identifier_1.ReferenceType.BuiltInFunction) {
+            // Tracked in #1207
+        }
+        else if (def.value !== undefined) {
+            /* if there is at least one location for which we have no idea, we have to give up for now! */
+            if (def.value.length === 0) {
+                return undefined;
+            }
+            for (const id of def.value) {
+                const value = graph.idMap?.get(id)?.content;
+                if (value !== undefined) {
+                    values.push(value);
+                }
+            }
+        }
+    }
+    if (values.length == 0) {
+        return undefined;
+    }
+    return values;
+}
+/**
+ * Convenience function using the variable resolver as specified within the configuration file
+ * In the future we may want to have this set once at the start of the analysis
+ */
+function resolveValueOfVariable(identifier, environment, graph) {
+    const resolve = (0, config_1.getConfig)().solver.variables;
+    switch (resolve) {
+        case config_1.VariableResolve.Alias: return resolveToValues(identifier, environment, graph);
+        case config_1.VariableResolve.Builtin: return resolveToConstants(identifier, environment);
+        case config_1.VariableResolve.Disabled: return [];
+        default: (0, assert_1.assertUnreachable)(resolve);
+    }
 }
 //# sourceMappingURL=resolve-by-name.js.map

package/dataflow/graph/vertex.d.ts

@@ -10,6 +10,57 @@ export declare enum VertexType {
     VariableDefinition = "variable-definition",
     FunctionDefinition = "function-definition"
 }
+/**
+ * A single index of a container, which is not a container itself.
+ *
+ * This can be e.g. a string, number or boolean index.
+ */
+export interface ContainerLeafIndex {
+    /**
+     * Destinctive lexeme of index e.g 'name' for `list(name = 'John')`
+     */
+    readonly lexeme: string;
+    /**
+     * NodeId of index in graph.
+     */
+    readonly nodeId: NodeId;
+}
+/**
+ * A single index of a container, which is a container itself.
+ *
+ * This can be, e.g., a list, vector, or data frame.
+ *
+ * @see {@link ContainerLeafIndex} - for a single index of a container which is not a container itself
+ * @see {@link isParentContainerIndex} - to check if an index is a parent container index
+ */
+export interface ContainerParentIndex extends ContainerLeafIndex {
+    /**
+     * Sub-indices of index.
+     */
+    readonly subIndices: ContainerIndices[];
+}
+export declare function isParentContainerIndex(index: ContainerIndex): index is ContainerParentIndex;
+/**
+ * A single index of a container.
+ */
+export type ContainerIndex = ContainerLeafIndex | ContainerParentIndex;
+/**
+ * List of indices of a single statement like `list(a=3, b=2)`
+ */
+export interface ContainerIndices {
+    readonly indices: ContainerIndex[];
+    /**
+     * Differentiate between single and multiple indices.
+     *
+     * For `list(name = 'John')` `isContainer` would be true, because a list may define more than one index.
+     * `isContainer` is true for e.g. single index assignments like `person$name <- 'John'`.
+     */
+    readonly isContainer: boolean;
+}
+/**
+ * Collection of Indices of several statements.
+ */
+export type ContainerIndicesCollection = ContainerIndices[] | undefined;
 /**
  * Arguments required to construct a vertex in the {@link DataflowGraph|dataflow graph}.
  *
@@ -31,11 +82,15 @@ interface DataflowGraphVertexBase extends MergeableRecord {
     /**
      * The environment in which the vertex is set.
      */
-    environment?: REnvironmentInformation | undefined;
+    environment?: REnvironmentInformation;
     /**
      * @see {@link ControlDependency} - the collection of control dependencies which have an influence on whether the vertex is executed.
      */
     controlDependencies: ControlDependency[] | undefined;
+    /**
+     * this attribute links a vertex to indices (pointer links) it may be affected by or related to
+     */
+    indicesCollection?: ContainerIndicesCollection;
 }
 /**
  * Marker vertex for a value in the dataflow of the program.

package/dataflow/graph/vertex.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VertexType = void 0;
+exports.isParentContainerIndex = isParentContainerIndex;
 exports.isValueVertex = isValueVertex;
 exports.isUseVertex = isUseVertex;
 exports.isFunctionCallVertex = isFunctionCallVertex;
@@ -14,6 +15,9 @@ var VertexType;
     VertexType["VariableDefinition"] = "variable-definition";
     VertexType["FunctionDefinition"] = "function-definition";
 })(VertexType || (exports.VertexType = VertexType = {}));
+function isParentContainerIndex(index) {
+    return 'subIndices' in index;
+}
 /**
  * Check if the given vertex is a {@link DataflowGraphVertexValue|value vertex}.
  */

package/dataflow/internal/process/functions/call/built-in/built-in-access.d.ts

@@ -5,6 +5,17 @@ import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/
 import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { ForceArguments } from '../common';
+/**
+ * Processes different types of access operations.
+ *
+ * Example:
+ * ```r
+ * a[i]
+ * a$foo
+ * a[[i]]
+ * a@foo
+ * ```
+ */
 export declare function processAccess<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
     treatIndicesAsString: boolean;
 } & ForceArguments): DataflowInformation;