@eagleoutice/flowr 2.2.13 → 2.2.15

package/dataflow/eval/values/r-value.d.ts

@@ -0,0 +1,58 @@
+import type { RNumberValue, RStringValue } from '../../../r-bridge/lang-4.x/convert-values';
+import type { RLogicalValue } from '../../../r-bridge/lang-4.x/ast/model/nodes/r-logical';
+export declare const Top: {
+    type: symbol;
+};
+export declare const Bottom: {
+    type: symbol;
+};
+export type Lift<N> = N | typeof Top | typeof Bottom;
+export type Unlift<N> = N extends typeof Top ? never : N extends typeof Bottom ? never : N;
+export interface ValueInterval<Limit extends ValueNumber = ValueNumber> {
+    type: 'interval';
+    start: Limit;
+    startInclusive: boolean;
+    end: Limit;
+    endInclusive: boolean;
+}
+/**
+ * An R vector with either a known set of elements or a known domain.
+ */
+export interface ValueVector<Elements extends Lift<unknown[]> = Lift<Value[]>, Domain extends Lift<Value> = Lift<Value>> {
+    type: 'vector';
+    elements: Elements;
+    /** if we do not know the amount of elements, we can still know the domain */
+    elementDomain: Domain;
+}
+/** describes the static case of we do not know which value */
+export interface ValueSet<Elements extends Lift<unknown[]> = Lift<Value[]>> {
+    type: 'set';
+    elements: Elements;
+}
+export interface ValueNumber<Num extends Lift<RNumberValue> = Lift<RNumberValue>> {
+    type: 'number';
+    value: Num;
+}
+export interface ValueString<Str extends Lift<RStringValue> = Lift<RStringValue>> {
+    type: 'string';
+    value: Str;
+}
+export interface ValueMissing {
+    type: 'missing';
+}
+export type TernaryLogical = RLogicalValue | 'maybe';
+export interface ValueLogical {
+    type: 'logical';
+    value: Lift<TernaryLogical>;
+}
+export type Value = Lift<ValueInterval | ValueVector | ValueSet | ValueNumber | ValueString | ValueLogical | ValueMissing>;
+export type ValueType<V> = V extends {
+    type: infer T;
+} ? T : never;
+export type ValueTypes = ValueType<Value>;
+export declare function typeOfValue<V extends Value>(value: V): V['type'];
+export declare function isTop<V extends Lift<unknown>>(value: V): value is typeof Top;
+export declare function isBottom<V extends Lift<unknown>>(value: V): value is typeof Bottom;
+export declare function isValue<V extends Lift<unknown>>(value: V): value is Unlift<V>;
+export declare function asValue<V extends Lift<unknown>>(value: V): Unlift<V>;
+export declare function stringifyValue(value: Lift<Value>): string;

package/dataflow/eval/values/r-value.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bottom = exports.Top = void 0;
+exports.typeOfValue = typeOfValue;
+exports.isTop = isTop;
+exports.isBottom = isBottom;
+exports.isValue = isValue;
+exports.asValue = asValue;
+exports.stringifyValue = stringifyValue;
+const assert_1 = require("../../../util/assert");
+exports.Top = { type: Symbol('⊤') };
+exports.Bottom = { type: Symbol('⊥') };
+function typeOfValue(value) {
+    return value.type;
+}
+// @ts-expect-error -- this is a save cast
+function isTop(value) {
+    return value === exports.Top;
+}
+// @ts-expect-error -- this is a save cast
+function isBottom(value) {
+    return value === exports.Bottom;
+}
+function isValue(value) {
+    return !isTop(value) && !isBottom(value);
+}
+function asValue(value) {
+    (0, assert_1.guard)(isValue(value), 'Expected a value, but got a top or bottom value');
+    return value;
+}
+function tryStringifyBoTop(value, otherwise, onTop = () => '⊤', onBottom = () => '⊥') {
+    if (isTop(value)) {
+        return onTop();
+    }
+    else if (isBottom(value)) {
+        return onBottom();
+    }
+    else {
+        return otherwise(value);
+    }
+}
+function stringifyRNumberSuffix(value) {
+    let suffix = '';
+    if (value.markedAsInt) {
+        suffix += 'L';
+    }
+    if (value.complexNumber) {
+        suffix += 'i';
+    }
+    // do something about iL even though it is impossible?
+    return suffix;
+}
+function renderString(value) {
+    const quote = value.quotes;
+    const raw = value.flag === 'raw';
+    if (raw) {
+        return `r${quote}(${value.str})${quote}`;
+    }
+    else {
+        return `${quote}${JSON.stringify(value.str).slice(1, -1)}${quote}`;
+    }
+}
+function stringifyValue(value) {
+    return tryStringifyBoTop(value, v => {
+        const t = v.type;
+        switch (t) {
+            case 'interval':
+                return `${v.startInclusive ? '[' : '('}${stringifyValue(v.start)}, ${stringifyValue(v.end)}${v.endInclusive ? ']' : ')'}`;
+            case 'vector':
+                return tryStringifyBoTop(v.elements, e => {
+                    return `<${stringifyValue(v.elementDomain)}> c(${e.map(stringifyValue).join(',')})`;
+                }, () => `⊤ (vector, ${stringifyValue(v.elementDomain)})`, () => `⊥ (vector, ${stringifyValue(v.elementDomain)})`);
+            case 'set':
+                return tryStringifyBoTop(v.elements, e => {
+                    return e.length === 1 ? stringifyValue(e[0]) : `{ ${e.map(stringifyValue).join(',')} }`;
+                }, () => '⊤ (set)', () => '⊥ (set)');
+            case 'number':
+                return tryStringifyBoTop(v.value, n => `${n.num}${stringifyRNumberSuffix(n)}`, () => '⊤ (number)', () => '⊥ (number)');
+            case 'string':
+                return tryStringifyBoTop(v.value, renderString, () => '⊤ (string)', () => '⊥ (string)');
+            case 'logical':
+                return tryStringifyBoTop(v.value, l => l === 'maybe' ? 'maybe' : l ? 'TRUE' : 'FALSE', () => '⊤ (logical)', () => '⊥ (logical)');
+            case 'missing':
+                return '(missing)';
+            default:
+                (0, assert_1.assertUnreachable)(t);
+        }
+    });
+}
+//# sourceMappingURL=r-value.js.map

package/dataflow/eval/values/scalar/scalar-consatnts.d.ts

@@ -0,0 +1,15 @@
+import type { Lift, ValueNumber } from '../r-value';
+import type { RNumberValue } from '../../../../r-bridge/lang-4.x/convert-values';
+export declare function getScalarFromInteger(num: number, markedAsInt?: boolean, complexNumber?: boolean): ValueNumber<RNumberValue>;
+export declare function liftScalar(value: Lift<RNumberValue>): ValueNumber;
+export declare const ValueIntegerOne: ValueNumber<RNumberValue>;
+export declare const ValueNumberComplexOne: ValueNumber<RNumberValue>;
+export declare const ValueIntegerZero: ValueNumber<RNumberValue>;
+export declare const ValueIntegerNegativeOne: ValueNumber<RNumberValue>;
+export declare const ValueIntegerPositiveInfinity: ValueNumber<RNumberValue>;
+export declare const ValueNumberPositiveInfinity: ValueNumber<RNumberValue>;
+export declare const ValueIntegerNegativeInfinity: ValueNumber<RNumberValue>;
+export declare const ValueNumberEpsilon: ValueNumber<RNumberValue>;
+export declare const ValueNumberOneHalf: ValueNumber<RNumberValue>;
+export declare const ValueIntegerTop: ValueNumber<Lift<RNumberValue>>;
+export declare const ValueIntegerBottom: ValueNumber<Lift<RNumberValue>>;

package/dataflow/eval/values/scalar/scalar-consatnts.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueIntegerBottom = exports.ValueIntegerTop = exports.ValueNumberOneHalf = exports.ValueNumberEpsilon = exports.ValueIntegerNegativeInfinity = exports.ValueNumberPositiveInfinity = exports.ValueIntegerPositiveInfinity = exports.ValueIntegerNegativeOne = exports.ValueIntegerZero = exports.ValueNumberComplexOne = exports.ValueIntegerOne = void 0;
+exports.getScalarFromInteger = getScalarFromInteger;
+exports.liftScalar = liftScalar;
+const r_value_1 = require("../r-value");
+function getScalarFromInteger(num, markedAsInt = Number.isInteger(num), complexNumber = false) {
+    return {
+        type: 'number',
+        value: {
+            markedAsInt,
+            num,
+            complexNumber
+        }
+    };
+}
+function liftScalar(value) {
+    return {
+        type: 'number',
+        value: value
+    };
+}
+const epsilon = 1e-7;
+exports.ValueIntegerOne = getScalarFromInteger(1);
+exports.ValueNumberComplexOne = getScalarFromInteger(1, false, true);
+exports.ValueIntegerZero = getScalarFromInteger(0);
+exports.ValueIntegerNegativeOne = getScalarFromInteger(-1);
+exports.ValueIntegerPositiveInfinity = getScalarFromInteger(Number.POSITIVE_INFINITY);
+exports.ValueNumberPositiveInfinity = getScalarFromInteger(Number.POSITIVE_INFINITY, false);
+exports.ValueIntegerNegativeInfinity = getScalarFromInteger(Number.NEGATIVE_INFINITY);
+exports.ValueNumberEpsilon = getScalarFromInteger(epsilon, false);
+exports.ValueNumberOneHalf = getScalarFromInteger(0.5, false);
+exports.ValueIntegerTop = liftScalar(r_value_1.Top);
+exports.ValueIntegerBottom = liftScalar(r_value_1.Bottom);
+//# sourceMappingURL=scalar-consatnts.js.map

package/dataflow/eval/values/sets/set-constants.d.ts

@@ -0,0 +1,7 @@
+import type { Lift, Value, ValueSet } from '../r-value';
+import { Top } from '../r-value';
+export declare function setFrom<V extends Value[]>(...elements: V): Lift<ValueSet<Value[]>>;
+export declare function isSet<V extends Value>(element: V): boolean;
+export declare const ValueEmptySet: Lift<ValueSet<Value[]>>;
+export declare const ValueSetTop: ValueSet<typeof Top>;
+export declare const ValueSetBottom: ValueSet<typeof Top>;

package/dataflow/eval/values/sets/set-constants.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueSetBottom = exports.ValueSetTop = exports.ValueEmptySet = void 0;
+exports.setFrom = setFrom;
+exports.isSet = isSet;
+const general_1 = require("../general");
+const r_value_1 = require("../r-value");
+function flattenSetElements(s) {
+    return (0, general_1.bottomTopGuard)(s) ?? s.flatMap(e => {
+        return e.type === 'set' ? flattenSetElements(e.elements) : e;
+    });
+}
+function setFrom(...elements) {
+    const vals = elements.flatMap(e => {
+        return e.type === 'set' ? flattenSetElements(e.elements) : e;
+    });
+    return (0, general_1.bottomTopGuard)(...vals) ?? {
+        type: 'set',
+        elements: vals
+    };
+}
+function isSet(element) {
+    return element.type === 'set';
+}
+exports.ValueEmptySet = setFrom();
+exports.ValueSetTop = {
+    type: 'set',
+    elements: r_value_1.Top
+};
+exports.ValueSetBottom = {
+    type: 'set',
+    elements: r_value_1.Top
+};
+//# sourceMappingURL=set-constants.js.map

package/dataflow/eval/values/string/string-constants.d.ts

@@ -0,0 +1,8 @@
+import type { RStringValue } from '../../../../r-bridge/lang-4.x/convert-values';
+import type { Lift, Value, ValueString } from '../r-value';
+export declare function stringFrom(str: RStringValue | string): ValueString;
+export declare function liftString(str: Lift<RStringValue>): ValueString;
+export declare function collectStrings(a: Value[]): string[] | undefined;
+export declare const ValueEmptyString: ValueString<Lift<RStringValue>>;
+export declare const ValueStringTop: ValueString<Lift<RStringValue>>;
+export declare const ValueStringBot: ValueString<Lift<RStringValue>>;

package/dataflow/eval/values/string/string-constants.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueStringBot = exports.ValueStringTop = exports.ValueEmptyString = void 0;
+exports.stringFrom = stringFrom;
+exports.liftString = liftString;
+exports.collectStrings = collectStrings;
+const general_1 = require("../general");
+const r_value_1 = require("../r-value");
+function stringFrom(str) {
+    return {
+        type: 'string',
+        value: typeof str === 'string' ? {
+            quotes: '"',
+            str: str
+        } : str,
+    };
+}
+function liftString(str) {
+    return {
+        type: 'string',
+        value: str
+    };
+}
+function collectStrings(a) {
+    if ((0, general_1.bottomTopGuard)(a)) {
+        return undefined;
+    }
+    const values = [];
+    for (const value of a) {
+        if (value.type !== 'string' || !(0, r_value_1.isValue)(value) || !(0, r_value_1.isValue)(value.value)) {
+            return undefined;
+        }
+        values.push(value.value.str);
+    }
+    return values;
+}
+exports.ValueEmptyString = stringFrom('');
+exports.ValueStringTop = liftString(r_value_1.Top);
+exports.ValueStringBot = liftString(r_value_1.Bottom);
+//# sourceMappingURL=string-constants.js.map

package/dataflow/eval/values/vectors/vector-constants.d.ts

@@ -0,0 +1,14 @@
+import type { Lift, Value, ValueVector } from '../r-value';
+/**
+ * Creates an abstract vector from abstract values
+ * @param elements - elements that the vector should contain
+ * @returns abstract ValueVector
+ */
+export declare function vectorFrom<V extends Lift<Value[]>>(elements: V): ValueVector<V>;
+/**
+ * Flattens all elements inside of a vector
+ * A set containing only one element is also replaced by its only element
+ * @param s - vector to flatten
+ * @returns flattened vactor, if all elements are not bottom / top
+ */
+export declare function flattenVectorElements(s: Lift<Value[]>): Lift<Value[]>;

package/dataflow/eval/values/vectors/vector-constants.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vectorFrom = vectorFrom;
+exports.flattenVectorElements = flattenVectorElements;
+const r_value_1 = require("../r-value");
+const assert_1 = require("../../../../util/assert");
+const general_1 = require("../general");
+/**
+ * Creates an abstract vector from abstract values
+ * @param elements - elements that the vector should contain
+ * @returns abstract ValueVector
+ */
+function vectorFrom(elements) {
+    (0, assert_1.guard)((0, r_value_1.isTop)(elements) || (0, r_value_1.isBottom)(elements) || Array.isArray(elements), 'Expected array of values');
+    return {
+        type: 'vector',
+        elements,
+        elementDomain: r_value_1.Top
+    };
+}
+/**
+ * Flattens all elements inside of a vector
+ * A set containing only one element is also replaced by its only element
+ * @param s - vector to flatten
+ * @returns flattened vactor, if all elements are not bottom / top
+ */
+function flattenVectorElements(s) {
+    return (0, general_1.bottomTopGuard)(s) ?? s.flatMap(e => {
+        return e.type === 'vector' ? flattenVectorElements(e.elements) :
+            e.type === 'set' && (0, r_value_1.isValue)(e.elements) && e.elements.length === 1 ?
+                e.elements[0].type === 'vector' ? flattenVectorElements(e.elements[0].elements) : e.elements :
+                e;
+    });
+}
+//# sourceMappingURL=vector-constants.js.map

package/dataflow/graph/unknown-replacement.d.ts

@@ -0,0 +1,11 @@
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { REnvironmentInformation } from '../environments/environment';
+export type ReplacementOperatorHandlerArgs = {
+    operator: string;
+    target: string | undefined;
+    env: REnvironmentInformation;
+    id: NodeId;
+};
+export type ReplacementOperatorHandler = (args: ReplacementOperatorHandlerArgs) => void;
+export declare function onReplacementOperator(handler: ReplacementOperatorHandler): void;
+export declare function handleReplacementOperator(args: ReplacementOperatorHandlerArgs): void;

package/dataflow/graph/unknown-replacement.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onReplacementOperator = onReplacementOperator;
+exports.handleReplacementOperator = handleReplacementOperator;
+const handlers = [];
+function onReplacementOperator(handler) {
+    handlers.push(handler);
+}
+function handleReplacementOperator(args) {
+    handlers.forEach(handler => handler(args));
+}
+//# sourceMappingURL=unknown-replacement.js.map

package/dataflow/graph/unknown-side-effect.d.ts

@@ -0,0 +1,7 @@
+import type { LinkTo } from '../../queries/catalog/call-context-query/call-context-query-format';
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { REnvironmentInformation } from '../environments/environment';
+import type { DataflowGraph } from './graph';
+export type UnknownSideEffectHandler = (graph: DataflowGraph, env: REnvironmentInformation, id: NodeId, target?: LinkTo<RegExp | string>) => void;
+export declare function onUnknownSideEffect(handler: UnknownSideEffectHandler): void;
+export declare function handleUnknownSideEffect(graph: DataflowGraph, env: REnvironmentInformation, id: NodeId, target?: LinkTo<RegExp | string>): void;

package/dataflow/graph/unknown-side-effect.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onUnknownSideEffect = onUnknownSideEffect;
+exports.handleUnknownSideEffect = handleUnknownSideEffect;
+const handlers = [];
+function onUnknownSideEffect(handler) {
+    handlers.push(handler);
+}
+function handleUnknownSideEffect(graph, env, id, target) {
+    graph.markIdForUnknownSideEffects(id, target);
+    handlers.forEach(handler => handler(graph, env, id, target));
+}
+//# sourceMappingURL=unknown-side-effect.js.map

package/dataflow/internal/process/functions/call/built-in/built-in-apply.js

@@ -10,7 +10,10 @@ const edge_1 = require("../../../../../graph/edge");
 const identifier_1 = require("../../../../../environments/identifier");
 const resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
 const unnamed_call_handling_1 = require("../unnamed-call-handling");
+const general_1 = require("../../../../../eval/values/general");
+const r_value_1 = require("../../../../../eval/values/r-value");
 const log_1 = require("../../../../../../util/log");
+const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
 function processApply(name, args, rootId, data, config) {
     const { indexOfFunction = 1, nameOfFunctionArgument, unquoteFunction, resolveInEnvironment, resolveValue } = config;
     /* as the length is one-based and the argument filter mapping is zero-based, we do not have to subtract 1 */
@@ -54,9 +57,9 @@ function processApply(name, args, rootId, data, config) {
     else if (val.type === type_1.RType.Symbol) {
         functionId = val.info.id;
         if (resolveValue) {
-            const resolved = (0, resolve_by_name_1.resolveValueOfVariable)(val.content, data.environment);
-            if (resolved?.length === 1 && typeof resolved[0] === 'string') {
-                functionName = resolved[0];
+            const resolved = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(val.info.id, { environment: data.environment, idMap: data.completeAst.idMap }));
+            if (resolved?.elements.length === 1 && resolved.elements[0].type === 'string') {
+                functionName = (0, r_value_1.isValue)(resolved.elements[0].value) ? resolved.elements[0].value.str : undefined;
             }
         }
         else {
@@ -72,7 +75,7 @@ function processApply(name, args, rootId, data, config) {
         logger_1.dataflowLogger.warn(`Expected symbol or string as function argument at index ${index}, but got ${JSON.stringify(val)} instead.`);
         return information;
     }
-    const allOtherArguments = processedArguments.filter((_, i) => i !== index).map((arg, i) => {
+    const allOtherArguments = processedArguments.map((arg, i) => {
         const counterpart = args[i];
         if (arg && counterpart !== r_function_call_1.EmptyArgument) {
             return {
@@ -85,7 +88,7 @@ function processApply(name, args, rootId, data, config) {
         else {
             return r_function_call_1.EmptyArgument;
         }
-    });
+    }).filter((_, i) => i !== index);
     if (anonymous) {
         const rootFnId = functionId;
         functionId = 'anon-' + rootFnId;

package/dataflow/internal/process/functions/call/built-in/built-in-assignment.js

@@ -20,6 +20,8 @@ const containers_1 = require("../../../../../../util/containers");
 const config_1 = require("../../../../../../config");
 const named_call_handling_1 = require("../named-call-handling");
 const built_in_1 = require("../../../../../environments/built-in");
+const unknown_side_effect_1 = require("../../../../../graph/unknown-side-effect");
+const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
 function toReplacementSymbol(target, prefix, superAssignment) {
     return {
         type: type_1.RType.Symbol,
@@ -142,7 +144,7 @@ args, rootId, data, config) {
         name, args: effectiveArgs, rootId, data, forceArgs: config.forceArgs,
         origin: 'builtin:assignment'
     }).information;
-    info.graph.markIdForUnknownSideEffects(rootId);
+    (0, unknown_side_effect_1.handleUnknownSideEffect)(info.graph, info.environment, rootId);
     return info;
 }
 function extractSourceAndTarget(args) {
@@ -269,7 +271,7 @@ function markAsAssignment(information, nodeToDefine, sourceIds, rootIdOfAssignme
 function processAssignmentToSymbol(config) {
     const { nameOfAssignmentFunction, source, args: [targetArg, sourceArg], target, rootId, data, information, makeMaybe, quoteSource } = config;
     const referenceType = checkTargetReferenceType(source, sourceArg);
-    const aliases = (0, resolve_by_name_1.getAliases)([source.info.id], information.graph, information.environment);
+    const aliases = (0, alias_tracking_1.getAliases)([source.info.id], information.graph, information.environment);
     const writeNodes = produceWrittenNodes(rootId, targetArg, referenceType, data, makeMaybe ?? false, aliases);
     if (writeNodes.length !== 1 && log_1.log.settings.minLevel <= 4 /* LogLevel.Warn */) {
         log_1.log.warn(`Unexpected write number in assignment: ${JSON.stringify(writeNodes)}`);

package/dataflow/internal/process/functions/call/built-in/built-in-eval.js

@@ -12,9 +12,12 @@ const log_1 = require("../../../../../../util/log");
 const built_in_source_1 = require("./built-in-source");
 const edge_1 = require("../../../../../graph/edge");
 const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
-const resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
 const append_1 = require("../../../../../environments/append");
 const assert_1 = require("../../../../../../util/assert");
+const general_1 = require("../../../../../eval/values/general");
+const string_constants_1 = require("../../../../../eval/values/string/string-constants");
+const unknown_side_effect_1 = require("../../../../../graph/unknown-side-effect");
+const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
 const arrays_1 = require("../../../../../../util/collections/arrays");
 function processEvalCall(name, args, rootId, data, config) {
     if (args.length !== 1 || args[0] === r_function_call_1.EmptyArgument || !args[0].value) {
@@ -30,7 +33,7 @@ function processEvalCall(name, args, rootId, data, config) {
     }
     if (!(0, config_1.getConfig)().solver.evalStrings) {
         (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Skipping eval call ${JSON.stringify(evalArgument)} (disabled in config file)`);
-        information.graph.markIdForUnknownSideEffects(rootId);
+        (0, unknown_side_effect_1.handleUnknownSideEffect)(information.graph, information.environment, rootId);
         return information;
     }
     const code = resolveEvalToCode(evalArgument.value, data.environment, data.completeAst.idMap);
@@ -62,7 +65,7 @@ function processEvalCall(name, args, rootId, data, config) {
         };
     }
     (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Non-constant argument ${JSON.stringify(args)} for eval is currently not supported, skipping`);
-    information.graph.markIdForUnknownSideEffects(rootId);
+    (0, unknown_side_effect_1.handleUnknownSideEffect)(information.graph, information.environment, rootId);
     return information;
 }
 function resolveEvalToCode(evalArgument, env, idMap) {
@@ -77,9 +80,9 @@ function resolveEvalToCode(evalArgument, env, idMap) {
             return [arg.value.content.str];
         }
         else if (arg.value?.type === type_1.RType.Symbol) {
-            const resolve = (0, resolve_by_name_1.resolveValueOfVariable)(arg.value.content, env, idMap);
-            if (resolve?.every(r => typeof r === 'object' && r !== null && 'str' in r)) {
-                return resolve.map(r => r.str);
+            const resolved = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(arg.value.info.id, { environment: env, idMap: idMap }));
+            if (resolved) {
+                return (0, string_constants_1.collectStrings)(resolved.elements);
             }
         }
         else if (arg.value?.type === type_1.RType.FunctionCall && arg.value.named && ['paste', 'paste0'].includes(arg.value.functionName.content)) {
@@ -104,9 +107,9 @@ function getAsString(val, env, idMap) {
         return [val.content.str];
     }
     else if (val.type === type_1.RType.Symbol) {
-        const resolved = (0, resolve_by_name_1.resolveValueOfVariable)(val.content, env, idMap);
-        if (resolved?.every(r => typeof r === 'object' && r !== null && 'str' in r)) {
-            return resolved.map(r => r.str);
+        const resolved = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(val.info.id, { environment: env, idMap: idMap }));
+        if (resolved) {
+            return (0, string_constants_1.collectStrings)(resolved.elements);
         }
     }
     return undefined;

package/dataflow/internal/process/functions/call/built-in/built-in-if-then-else.js

@@ -7,11 +7,12 @@ const known_call_handling_1 = require("../known-call-handling");
 const common_1 = require("../common");
 const unpack_argument_1 = require("../argument/unpack-argument");
 const logger_1 = require("../../../../../logger");
-const resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
 const edge_1 = require("../../../../../graph/edge");
 const append_1 = require("../../../../../environments/append");
 const identifier_1 = require("../../../../../environments/identifier");
 const environment_1 = require("../../../../../environments/environment");
+const general_1 = require("../../../../../eval/values/general");
+const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
 function processIfThenElse(name, args, rootId, data) {
     if (args.length !== 2 && args.length !== 3) {
         logger_1.dataflowLogger.warn(`If-then-else ${name.content} has something different from 2 or 3 arguments, skipping`);
@@ -33,9 +34,9 @@ function processIfThenElse(name, args, rootId, data) {
     let then;
     let makeThenMaybe = false;
     // we should defer this to the abstract interpretation
-    const values = (0, resolve_by_name_1.resolveValueOfVariable)(condArg?.lexeme, data.environment, data.completeAst.idMap);
-    const conditionIsAlwaysFalse = values?.every(d => d === false) ?? false;
-    const conditionIsAlwaysTrue = values?.every(d => d === true) ?? false;
+    const values = (0, alias_tracking_1.resolveIdToValue)(condArg?.info.id, { environment: data.environment, idMap: data.completeAst.idMap });
+    const conditionIsAlwaysFalse = (0, general_1.valueSetGuard)(values)?.elements.every(d => d.type === 'logical' && d.value === false) ?? false;
+    const conditionIsAlwaysTrue = (0, general_1.valueSetGuard)(values)?.elements.every(d => d.type === 'logical' && d.value === true) ?? false;
     if (!conditionIsAlwaysFalse) {
         then = (0, processor_1.processDataflowFor)(thenArg, data);
         if (then.entryPoint) {

package/dataflow/internal/process/functions/call/built-in/built-in-replacement.js

@@ -17,6 +17,7 @@ const unpack_argument_1 = require("../argument/unpack-argument");
 const built_in_access_1 = require("./built-in-access");
 const built_in_1 = require("../../../../../environments/built-in");
 const identifier_1 = require("../../../../../environments/identifier");
+const unknown_replacement_1 = require("../../../../../graph/unknown-replacement");
 function processReplacementFunction(name, 
 /** The last one has to be the value */
 args, rootId, data, config) {
@@ -60,9 +61,15 @@ args, rootId, data, config) {
         origin: 'builtin:replacement',
         link: config.assignRootId ? { origin: [config.assignRootId] } : undefined
     });
-    const firstArg = (0, unpack_argument_1.unpackArgument)(args[0])?.info.id;
+    const firstArg = (0, unpack_argument_1.unpackArgument)(args[0]);
+    (0, unknown_replacement_1.handleReplacementOperator)({
+        operator: name.content,
+        target: firstArg?.lexeme,
+        env: res.environment,
+        id: rootId
+    });
     if (firstArg) {
-        res.graph.addEdge(firstArg, rootId, edge_1.EdgeType.DefinedBy | edge_1.EdgeType.Reads);
+        res.graph.addEdge(firstArg.info.id, rootId, edge_1.EdgeType.DefinedBy | edge_1.EdgeType.Reads);
     }
     /* a replacement reads all of its call args as well, at least as far as I am aware of */
     for (const arg of callArgs) {