@eagleoutice/flowr 2.2.15 → 2.3.0

package/dataflow/environments/built-in.js

@@ -42,7 +42,7 @@ function isBuiltIn(name) {
     return String(name).startsWith('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, origin: 'builtin:default' });
+    const { information: res, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs, origin: config.useAsProcessor ?? 'builtin:default' });
     if (config.returnsNthArgument !== undefined) {
         const arg = config.returnsNthArgument === 'last' ? processedArguments[args.length - 1] : processedArguments[config.returnsNthArgument];
         if (arg !== undefined) {
@@ -90,7 +90,7 @@ function defaultBuiltInProcessor(name, args, rootId, data, config) {
                     environment: data.environment,
                     onlyBuiltin: false,
                     cds: data.controlDependencies,
-                    origin: ['builtin:default']
+                    origin: [config.useAsProcessor ?? 'builtin:default']
                 });
             }
         }
@@ -144,7 +144,9 @@ exports.BuiltInProcessorMapper = {
 };
 exports.BuiltInEvalHandlerMapper = {
     'built-in:c': resolve_1.resolveAsVector,
-    'builtin:vector': resolve_1.resolveAsVector
+    'built-in::': resolve_1.resolveAsSeq,
+    'built-in:+': resolve_1.resolveAsPlus,
+    'built-in:-': resolve_1.resolveAsMinus
 };
 exports.BuiltInMemory = new Map();
 exports.EmptyBuiltInMemory = new Map();

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

@@ -102,7 +102,7 @@ exports.DefaultBuiltinConfig = [
             '~', '+', '-', '*', '/', '^', '!', '?', '**', '==', '!=', '>', '<', '>=', '<=', '%%', '%/%', '%*%', '%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',
+            'unique', 'paste', 'paste0', 'read.csv', 'is.null', 'numeric', 'as.character', 'as.integer', 'as.logical', 'as.numeric', 'as.matrix',
             'rbind', 'nrow', 'ncol', 'tryCatch', 'expression', 'factor',
             'missing', 'as.data.frame', 'data.frame', 'na.omit', 'rownames', 'names', 'order', 'length', 'any', 'dim', 'matrix', 'cbind', 'nchar',
             'pdf', 'jpeg', 'png', 'windows', 'postscript', 'xfig', 'bitmap', 'pictex', 'cairo_pdf', 'svg', 'bmp', 'tiff', 'X11', 'quartz',
@@ -215,7 +215,9 @@ exports.DefaultBuiltinConfig = [
     { type: 'function', names: ['eval'], processor: 'builtin:eval', config: { includeFunctionCall: true }, assumePrimitive: true },
     { type: 'function', names: ['cat'], processor: 'builtin:default', config: { forceArgs: 'all', hasUnknownSideEffects: { type: 'link-to-last-call', callName: /^sink$/ } }, assumePrimitive: false },
     { type: 'function', names: ['switch'], processor: 'builtin:default', config: { forceArgs: [true] }, assumePrimitive: false },
-    { type: 'function', names: ['return'], processor: 'builtin:default', config: { returnsNthArgument: 0, cfg: 1 /* ExitPointType.Return */ }, assumePrimitive: false },
+    { type: 'function', names: ['return'], processor: 'builtin:default', config: { returnsNthArgument: 0, cfg: 1 /* ExitPointType.Return */, useAsProcessor: 'builtin:return' }, assumePrimitive: false },
+    { type: 'function', names: ['stop'], processor: 'builtin:default', config: { useAsProcessor: 'builtin:stop' }, assumePrimitive: false },
+    { type: 'function', names: ['stopifnot'], processor: 'builtin:default', config: { useAsProcessor: 'builtin:stopifnot' }, assumePrimitive: false },
     { type: 'function', names: ['break'], processor: 'builtin:default', config: { cfg: 2 /* ExitPointType.Break */ }, assumePrimitive: false },
     { type: 'function', names: ['next'], processor: 'builtin:default', config: { cfg: 3 /* ExitPointType.Next */ }, assumePrimitive: false },
     { type: 'function', names: ['{'], processor: 'builtin:expression-list', config: {}, assumePrimitive: true },

package/dataflow/environments/define.d.ts

@@ -1,5 +1,6 @@
 import type { REnvironmentInformation } from './environment';
 import type { IdentifierDefinition, InGraphIdentifierDefinition } from './identifier';
+import type { FlowrConfigOptions } from '../../config';
 /**
  * assumes: existing is not undefined, the overwrite has indices
  */
@@ -8,4 +9,4 @@ export declare function mergeDefinitions(existing: readonly IdentifierDefinition
  * 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.
  */
-export declare function define(definition: IdentifierDefinition, superAssign: boolean | undefined, environment: REnvironmentInformation): REnvironmentInformation;
+export declare function define(definition: IdentifierDefinition, superAssign: boolean | undefined, environment: REnvironmentInformation, config: FlowrConfigOptions): REnvironmentInformation;

package/dataflow/environments/define.js

@@ -6,12 +6,11 @@ const assert_1 = require("../../util/assert");
 const environment_1 = require("./environment");
 const clone_1 = require("./clone");
 const vertex_1 = require("../graph/vertex");
-const config_1 = require("../../config");
-function defInEnv(newEnvironments, name, definition) {
+function defInEnv(newEnvironments, name, definition, config) {
     const existing = newEnvironments.memory.get(name);
     // When there are defined indices, merge the definitions
     const inGraphDefinition = definition;
-    if ((0, config_1.getConfig)().solver.pointerTracking &&
+    if (config.solver.pointerTracking &&
         existing !== undefined &&
         inGraphDefinition.controlDependencies === undefined) {
         if (inGraphDefinition.indicesCollection !== undefined) {
@@ -122,7 +121,7 @@ function overwriteContainerIndices(existingIndices, overwriteIndex) {
  * 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.
  */
-function define(definition, superAssign, environment) {
+function define(definition, superAssign, environment, config) {
     const name = definition.name;
     (0, assert_1.guard)(name !== undefined, () => `Name must be defined, but isn't for ${JSON.stringify(definition)}`);
     let newEnvironment;
@@ -147,7 +146,7 @@ function define(definition, superAssign, environment) {
     }
     else {
         newEnvironment = (0, clone_1.cloneEnvironmentInformation)(environment, false);
-        defInEnv(newEnvironment.current, name, definition);
+        defInEnv(newEnvironment.current, name, definition, config);
     }
     return newEnvironment;
 }

package/dataflow/environments/remove.d.ts

@@ -1,6 +1,12 @@
 import type { REnvironmentInformation } from './environment';
 import type { Identifier } from './identifier';
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 /**
  * Removes all definitions of a given name from the environment.
  */
 export declare function remove(name: Identifier, environment: REnvironmentInformation): REnvironmentInformation;
+/** Creates a copy of the original environment but without the definitions of the given ids */
+export declare function removeAll(definitions: readonly {
+    nodeId: NodeId;
+    name: Identifier | undefined;
+}[], environment: REnvironmentInformation): REnvironmentInformation;

package/dataflow/environments/remove.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.remove = remove;
+exports.removeAll = removeAll;
 const environment_1 = require("./environment");
 const info_1 = require("../info");
+const clone_1 = require("./clone");
 /**
  * Removes all definitions of a given name from the environment.
  */
@@ -21,4 +23,31 @@ function remove(name, environment) {
     // we never remove built ins
     return environment;
 }
+/** Creates a copy of the original environment but without the definitions of the given ids */
+function removeAll(definitions, environment) {
+    environment = (0, clone_1.cloneEnvironmentInformation)(environment, true);
+    let current = environment.current;
+    do {
+        for (const { nodeId, name } of definitions) {
+            if (name) {
+                current.memory.delete(name);
+            }
+            else {
+                // remove all definitions for the node id
+                for (const [key, values] of current.memory) {
+                    const res = values.filter(v => v.nodeId === nodeId);
+                    if (res.length > 0) {
+                        current.memory.set(key, values);
+                    }
+                    else {
+                        current.memory.delete(key);
+                    }
+                }
+            }
+        }
+        current = current.parent;
+    } while (current.id !== environment_1.BuiltInEnvironment.id);
+    // we never remove built ins so we can stop one early
+    return environment;
+}
 //# sourceMappingURL=remove.js.map

package/dataflow/eval/resolve/alias-tracking.d.ts

@@ -1,3 +1,4 @@
+import { VariableResolve } from '../../../config';
 import type { AstIdMap, RNodeWithParent } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { REnvironmentInformation } from '../../environments/environment';
@@ -14,6 +15,8 @@ export interface ResolveInfo {
     graph?: DataflowGraph;
     /** Whether to track variables */
     full?: boolean;
+    /** Variable resolve mode */
+    resolve: VariableResolve;
 }
 /**
  * Gets the definitions / aliases of a node
@@ -48,8 +51,9 @@ export declare function getAliases(sourceIds: readonly NodeId[], dataflow: Dataf
  * @param graph       - The graph to resolve in
  * @param idMap       - The id map to resolve the node if given as an id
  * @param full        - Whether to track aliases on resolve
+ * @param resolve     - Variable resolve mode
  */
-export declare function resolveIdToValue(id: NodeId | RNodeWithParent | undefined, { environment, graph, idMap, full }: ResolveInfo): ResolveResult;
+export declare function resolveIdToValue(id: NodeId | RNodeWithParent | undefined, { environment, graph, idMap, full, resolve }: ResolveInfo): ResolveResult;
 /**
  * Please use {@link resolveIdToValue}
  *
@@ -57,13 +61,14 @@ export declare function resolveIdToValue(id: NodeId | RNodeWithParent | undefine
  * {@link getAliases} function) to resolve a node to a value.
  *
  *
+ * @param resolve    - Variable resolve mode
  * @param identifier - Identifier to resolve
  * @param use        - Environment to use
  * @param graph      - Dataflow graph
  * @param idMap      - id map of Dataflow graph
  * @returns Value of Identifier or Top
  */
-export declare function trackAliasInEnvironments(identifier: Identifier | undefined, use: REnvironmentInformation, graph?: DataflowGraph, idMap?: AstIdMap): ResolveResult;
+export declare function trackAliasInEnvironments(resolve: VariableResolve, identifier: Identifier | undefined, use: REnvironmentInformation, graph?: DataflowGraph, idMap?: AstIdMap): ResolveResult;
 /**
  * Please use {@link resolveIdToValue}
  *

package/dataflow/eval/resolve/alias-tracking.js

@@ -115,8 +115,9 @@ function getAliases(sourceIds, dataflow, environment) {
  * @param graph       - The graph to resolve in
  * @param idMap       - The id map to resolve the node if given as an id
  * @param full        - Whether to track aliases on resolve
+ * @param resolve     - Variable resolve mode
  */
-function resolveIdToValue(id, { environment, graph, idMap, full = true }) {
+function resolveIdToValue(id, { environment, graph, idMap, full = true, resolve }) {
     if (id === undefined) {
         return r_value_1.Top;
     }
@@ -129,16 +130,18 @@ function resolveIdToValue(id, { environment, graph, idMap, full = true }) {
         case type_1.RType.Argument:
         case type_1.RType.Symbol:
             if (environment) {
-                return full ? trackAliasInEnvironments(node.lexeme, environment, graph, idMap) : r_value_1.Top;
+                return full ? trackAliasInEnvironments(resolve, node.lexeme, environment, graph, idMap) : r_value_1.Top;
             }
-            else if (graph && (0, config_1.getConfig)().solver.variables === config_1.VariableResolve.Alias) {
+            else if (graph && resolve === config_1.VariableResolve.Alias) {
                 return full ? trackAliasesInGraph(node.info.id, graph, idMap) : r_value_1.Top;
             }
             else {
                 return r_value_1.Top;
             }
         case type_1.RType.FunctionCall:
-            return (0, set_constants_1.setFrom)((0, resolve_1.resolveNode)(node, environment, graph, idMap));
+        case type_1.RType.BinaryOp:
+        case type_1.RType.UnaryOp:
+            return (0, set_constants_1.setFrom)((0, resolve_1.resolveNode)(resolve, node, environment, graph, idMap));
         case type_1.RType.String:
         case type_1.RType.Number:
         case type_1.RType.Logical:
@@ -154,13 +157,14 @@ function resolveIdToValue(id, { environment, graph, idMap, full = true }) {
  * {@link getAliases} function) to resolve a node to a value.
  *
  *
+ * @param resolve    - Variable resolve mode
  * @param identifier - Identifier to resolve
  * @param use        - Environment to use
  * @param graph      - Dataflow graph
  * @param idMap      - id map of Dataflow graph
  * @returns Value of Identifier or Top
  */
-function trackAliasInEnvironments(identifier, use, graph, idMap) {
+function trackAliasInEnvironments(resolve, identifier, use, graph, idMap) {
     if (identifier === undefined) {
         return r_value_1.Top;
     }
@@ -184,7 +188,7 @@ function trackAliasInEnvironments(identifier, use, graph, idMap) {
             for (const alias of def.value) {
                 const definitionOfAlias = idMap?.get(alias);
                 if (definitionOfAlias !== undefined) {
-                    const value = (0, resolve_1.resolveNode)(definitionOfAlias, use, graph, idMap);
+                    const value = (0, resolve_1.resolveNode)(resolve, definitionOfAlias, use, graph, idMap);
                     if ((0, r_value_1.isTop)(value)) {
                         return r_value_1.Top;
                     }
@@ -198,6 +202,7 @@ function trackAliasInEnvironments(identifier, use, graph, idMap) {
     }
     return (0, set_constants_1.setFrom)(...values);
 }
+/** given an unknown alias, we have to clear all values in the environments */
 (0, unknown_side_effect_1.onUnknownSideEffect)((_graph, env, _id, target) => {
     if (target) {
         return;
@@ -258,8 +263,6 @@ function isNestedInLoop(node, ast) {
 function trackAliasesInGraph(id, graph, idMap) {
     idMap ??= graph.idMap;
     (0, assert_1.guard)(idMap !== undefined, 'The ID map is required to get the lineage of a node');
-    const start = graph.getVertex(id);
-    (0, assert_1.guard)(start !== undefined, 'Unable to find start for alias tracking');
     const queue = new visiting_queue_1.VisitingQueue(25);
     const clean = (0, environment_1.initializeCleanEnvironments)();
     const cleanFingerprint = (0, fingerprint_1.envFingerprint)(clean);

package/dataflow/eval/resolve/resolve-argument.d.ts

@@ -0,0 +1,8 @@
+import type { DataflowGraph } from '../../graph/graph';
+import type { DataflowGraphVertexFunctionCall } from '../../graph/vertex';
+import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { VariableResolve } from '../../../config';
+/**
+ * Get the values of all arguments matching the criteria.
+ */
+export declare function getArgumentStringValue(variableResolve: VariableResolve, graph: DataflowGraph, vertex: DataflowGraphVertexFunctionCall, argumentIndex: number | 'unnamed' | undefined, argumentName: string | undefined, resolveValue: boolean | 'library' | undefined): Map<NodeId, Set<string | undefined>> | undefined;

package/dataflow/eval/resolve/resolve-argument.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getArgumentStringValue = getArgumentStringValue;
+const graph_1 = require("../../graph/graph");
+const r_function_call_1 = require("../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const assert_1 = require("../../../util/assert");
+const type_1 = require("../../../r-bridge/lang-4.x/ast/model/type");
+const dependencies_query_format_1 = require("../../../queries/catalog/dependencies-query/dependencies-query-format");
+const general_1 = require("../values/general");
+const alias_tracking_1 = require("./alias-tracking");
+const r_value_1 = require("../values/r-value");
+const convert_values_1 = require("../../../r-bridge/lang-4.x/convert-values");
+const string_constants_1 = require("../values/string/string-constants");
+/**
+ * Get the values of all arguments matching the criteria.
+ */
+function getArgumentStringValue(variableResolve, graph, vertex, argumentIndex, argumentName, resolveValue) {
+    if (argumentName) {
+        const arg = vertex?.args.findIndex(arg => arg !== r_function_call_1.EmptyArgument && arg.name === argumentName);
+        if (arg >= 0) {
+            argumentIndex = arg;
+        }
+    }
+    if (!vertex || argumentIndex === undefined) {
+        return undefined;
+    }
+    if (argumentIndex === 'unnamed') {
+        // return all unnamed arguments
+        const references = vertex.args.filter(arg => arg !== r_function_call_1.EmptyArgument && !arg.name).map(graph_1.getReferenceOfArgument).filter(assert_1.isNotUndefined);
+        const map = new Map();
+        for (const ref of references) {
+            let valueNode = graph.idMap?.get(ref);
+            if (valueNode?.type === type_1.RType.Argument) {
+                valueNode = valueNode.value;
+            }
+            if (valueNode) {
+                // this should be evaluated in the callee-context
+                const values = resolveBasedOnConfig(variableResolve, graph, vertex, valueNode, vertex.environment, graph.idMap, resolveValue) ?? [dependencies_query_format_1.Unknown];
+                map.set(ref, new Set(values));
+            }
+        }
+        return map;
+    }
+    if (argumentIndex < vertex.args.length) {
+        const arg = (0, graph_1.getReferenceOfArgument)(vertex.args[argumentIndex]);
+        if (!arg) {
+            return undefined;
+        }
+        let valueNode = graph.idMap?.get(arg);
+        if (valueNode?.type === type_1.RType.Argument) {
+            valueNode = valueNode.value;
+        }
+        if (valueNode) {
+            const values = resolveBasedOnConfig(variableResolve, graph, vertex, valueNode, vertex.environment, graph.idMap, resolveValue) ?? [dependencies_query_format_1.Unknown];
+            return new Map([[arg, new Set(values)]]);
+        }
+    }
+    return undefined;
+}
+function hasCharacterOnly(variableResolve, graph, vertex, idMap) {
+    if (!vertex.args || vertex.args.length === 0 || !idMap) {
+        return false;
+    }
+    const treatAsChar = getArgumentStringValue(variableResolve, graph, vertex, 5, 'character.only', true);
+    if (!treatAsChar) {
+        return false;
+    }
+    const hasTrue = [...treatAsChar.values()].some(set => set?.has('TRUE'));
+    const hasFalse = hasTrue ? [...treatAsChar.values()].some(set => set === undefined || set.has('FALSE')) : false;
+    if (hasTrue && hasFalse) {
+        return 'maybe';
+    }
+    else {
+        return hasTrue;
+    }
+}
+function resolveBasedOnConfig(variableResolve, graph, vertex, argument, environment, idMap, resolveValue) {
+    let full = true;
+    if (!resolveValue) {
+        full = false;
+    }
+    if (resolveValue === 'library') {
+        const hasChar = hasCharacterOnly(variableResolve, graph, vertex, idMap);
+        if (hasChar === false) {
+            if (argument.type === type_1.RType.Symbol) {
+                return [argument.lexeme];
+            }
+            full = false;
+        }
+    }
+    const resolved = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(argument, { environment, graph, full, resolve: variableResolve }));
+    if (resolved) {
+        const values = [];
+        for (const value of resolved.elements) {
+            if (!(0, r_value_1.isValue)(value)) {
+                return undefined;
+            }
+            else if (value.type === 'string' && (0, r_value_1.isValue)(value.value)) {
+                values.push(value.value.str);
+            }
+            else if (value.type === 'logical' && (0, r_value_1.isValue)(value.value)) {
+                values.push(value.value.valueOf() ? convert_values_1.RTrue : convert_values_1.RFalse);
+            }
+            else if (value.type === 'vector' && (0, r_value_1.isValue)(value.elements)) {
+                const elements = (0, string_constants_1.collectStrings)(value.elements, !full);
+                if (elements === undefined) {
+                    return undefined;
+                }
+                values.push(...elements);
+            }
+            else {
+                return undefined;
+            }
+        }
+        return values;
+    }
+}
+//# sourceMappingURL=resolve-argument.js.map

package/dataflow/eval/resolve/resolve.d.ts

@@ -1,34 +1,81 @@
 import type { AstIdMap, RNodeWithParent } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { REnvironmentInformation } from '../../environments/environment';
 import type { DataflowGraph } from '../../graph/graph';
-import type { Value } from '../values/r-value';
+import type { Lift, Value, ValueNumber, ValueVector } from '../values/r-value';
+import { Top } from '../values/r-value';
+import type { VariableResolve } from '../../../config';
 /**
  * Helper function used by {@link resolveIdToValue}, please use that instead, if
- * you want to resolve the value of a identifier / node
+ * you want to resolve the value of an identifier / node
  *
- * This function converts an RNode to its Value, but also recursivly resolves
+ * This function converts an RNode to its Value, but also recursively resolves
  * aliases and vectors (in case of a vector).
  *
- * @param a     - Ast node to resolve
- * @param env   - Environment to use
- * @param graph - Dataflow Graph to use
- * @param map   - Idmap of Dataflow Graph
+ * @param a       - Ast node to resolve
+ * @param resolve - Variable resolve mode
+ * @param env     - Environment to use
+ * @param graph   - Dataflow Graph to use
+ * @param map     - Idmap of Dataflow Graph
  * @returns resolved value or top/bottom
  */
-export declare function resolveNode(a: RNodeWithParent, env?: REnvironmentInformation, graph?: DataflowGraph, map?: AstIdMap): Value;
+export declare function resolveNode(resolve: VariableResolve, a: RNodeWithParent, env?: REnvironmentInformation, graph?: DataflowGraph, map?: AstIdMap): Value;
 /**
  * Helper function used by {@link resolveIdToValue}, please use that instead, if
- * you want to resolve the value of a identifier / node
+ * you want to resolve the value of an identifier / node
  *
- * This function converts an rnode to a Value Vector {@link vectorFrom}
- * It also recursivly resolves any symbols, values, function calls (only c), in
- * order to construct the value of the vector to resolve by calling {@link resolveIdToValue}
- * or {@link resolveNode}
+ * This function resolves a vector function call `c` to a {@link ValueVector}
+ * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
  *
- * @param a     - Node of the vector to resolve
- * @param env   - Environment to use
- * @param graph - Dataflow graph
- * @param map   - Idmap of Dataflow Graph
+ * @param resolve - Variable resolve mode
+ * @param node    - Node of the vector function to resolve
+ * @param env     - Environment to use
+ * @param graph   - Dataflow graph
+ * @param map     - Id map of the dataflow graph
  * @returns ValueVector or Top
  */
-export declare function resolveAsVector(a: RNodeWithParent, env: REnvironmentInformation, graph?: DataflowGraph, map?: AstIdMap): Value;
+export declare function resolveAsVector(resolve: VariableResolve, node: RNodeWithParent, environment?: REnvironmentInformation, graph?: DataflowGraph, idMap?: AstIdMap): ValueVector<Lift<Value[]>> | typeof Top;
+/**
+ * Helper function used by {@link resolveIdToValue}, please use that instead, if
+ * you want to resolve the value of an identifier / node
+ *
+ * This function resolves a binary sequence operator `:` to a {@link ValueVector} of {@link ValueNumber}s
+ * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
+ *
+ * @param resolve  - Variable resolve mode
+ * @param operator - Node of the sequence operator to resolve
+ * @param env      - Environment to use
+ * @param graph    - Dataflow graph
+ * @param map      - Id map of the dataflow graph
+ * @returns ValueVector of ValueNumbers or Top
+ */
+export declare function resolveAsSeq(resolve: VariableResolve, operator: RNodeWithParent, environment?: REnvironmentInformation, graph?: DataflowGraph, idMap?: AstIdMap): ValueVector<Lift<ValueNumber[]>> | typeof Top;
+/**
+ * Helper function used by {@link resolveIdToValue}, please use that instead, if
+ * you want to resolve the value of an identifier / node
+ *
+ * This function resolves a unary plus operator `+` to a {@link ValueNumber} or {@link ValueVector} of ValueNumbers
+ * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
+ *
+ * @param resolve  - Variable resolve mode
+ * @param operator - Node of the plus operator to resolve
+ * @param env      - Environment to use
+ * @param graph    - Dataflow graph
+ * @param map      - Id map of the dataflow graph
+ * @returns ValueNumber, ValueVector of ValueNumbers, or Top
+ */
+export declare function resolveAsPlus(resolve: VariableResolve, operator: RNodeWithParent, environment?: REnvironmentInformation, graph?: DataflowGraph, idMap?: AstIdMap): ValueNumber | ValueVector<Lift<ValueNumber[]>> | typeof Top;
+/**
+ * Helper function used by {@link resolveIdToValue}, please use that instead, if
+ * you want to resolve the value of an identifier / node
+ *
+ * This function resolves a unary minus operator `-` to a {@link ValueNumber} or {@link ValueVector} of ValueNumbers
+ * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
+ *
+ * @param resolve  - Variable resolve mode
+ * @param operator - Node of the minus operator to resolve
+ * @param env      - Environment to use
+ * @param graph    - Dataflow graph
+ * @param map      - Id map of the dataflow graph
+ * @returns ValueNumber, ValueVector of ValueNumbers, or Top
+ */
+export declare function resolveAsMinus(resolve: VariableResolve, operator: RNodeWithParent, environment?: REnvironmentInformation, graph?: DataflowGraph, idMap?: AstIdMap): ValueNumber | ValueVector<Lift<ValueNumber[]>> | typeof Top;