@eagleoutice/flowr 2.2.14 → 2.2.16

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

@@ -2,9 +2,6 @@ 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';
-import type { AstIdMap, RNodeWithParent } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 /**
  * Resolves a given identifier name to a list of its possible definition location using R scoping and resolving rules.
  *
@@ -17,36 +14,3 @@ import type { AstIdMap, RNodeWithParent } from '../../r-bridge/lang-4.x/ast/mode
  */
 export declare function resolveByName(name: Identifier, environment: REnvironmentInformation, target?: ReferenceType): IdentifierDefinition[] | undefined;
 export declare function resolvesToBuiltInConstant(name: Identifier | undefined, environment: REnvironmentInformation, wantedValue: unknown): Ternary;
-/** Please use {@link resolveValueOfVariable} */
-export declare function resolveToConstants(name: Identifier | undefined, environment: REnvironmentInformation): unknown[] | undefined;
-export declare function getAliases(sourceIds: readonly NodeId[], dataflow: DataflowGraph, environment: REnvironmentInformation): NodeId[] | undefined;
-/** Please use {@link resolveValueOfVariable} */
-export declare function trackAliasInEnvironments(identifier: Identifier | undefined, use: REnvironmentInformation, idMap?: AstIdMap): unknown[] | undefined;
-export declare function trackAliasesInGraph(id: NodeId, graph: DataflowGraph, idMap?: AstIdMap): 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
- *
- * @see {@link resolveIdToValue} - for a more general approach which "evaluates" a node based on value resolve
- */
-export declare function resolveValueOfVariable(identifier: Identifier | undefined, environment: REnvironmentInformation, idMap?: AstIdMap): unknown[] | undefined;
-export interface ResolveInfo {
-    /** The current environment used for name resolution */
-    environment?: REnvironmentInformation;
-    /** The id map to resolve the node if given as an id */
-    idMap?: AstIdMap;
-    /** The graph to resolve in */
-    graph?: DataflowGraph;
-    /** Whether to track variables */
-    full?: boolean;
-}
-/**
- * Generalized {@link resolveValueOfVariable} function which evaluates a node based on the value resolve
- *
- * @param id          - The node id or node to resolve
- * @param environment - The current environment used for name resolution
- * @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 variables
- */
-export declare function resolveIdToValue(id: NodeId | RNodeWithParent, { environment, graph, idMap, full }: ResolveInfo): unknown[] | undefined;

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

@@ -2,24 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveByName = resolveByName;
 exports.resolvesToBuiltInConstant = resolvesToBuiltInConstant;
-exports.resolveToConstants = resolveToConstants;
-exports.getAliases = getAliases;
-exports.trackAliasInEnvironments = trackAliasInEnvironments;
-exports.trackAliasesInGraph = trackAliasesInGraph;
-exports.resolveValueOfVariable = resolveValueOfVariable;
-exports.resolveIdToValue = resolveIdToValue;
 const environment_1 = require("./environment");
 const logic_1 = require("../../util/logic");
 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 type_1 = require("../../r-bridge/lang-4.x/ast/model/type");
-const visiting_queue_1 = require("../../slicing/static/visiting-queue");
-const fingerprint_1 = require("../../slicing/static/fingerprint");
-const edge_1 = require("../graph/edge");
 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;
@@ -96,230 +82,4 @@ function resolvesToBuiltInConstant(name, environment, wantedValue) {
         return some ? logic_1.Ternary.Maybe : logic_1.Ternary.Never;
     }
 }
-/** Please use {@link resolveValueOfVariable} */
-function resolveToConstants(name, environment) {
-    if (name === undefined) {
-        return undefined;
-    }
-    const definitions = resolveByName(name, environment, identifier_1.ReferenceType.Constant);
-    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) {
-    let 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;
-    }
-    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 = definitions.concat(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];
-}
-/** Please use {@link resolveValueOfVariable} */
-function trackAliasInEnvironments(identifier, use, idMap) {
-    if (identifier === undefined) {
-        return undefined;
-    }
-    const defs = resolveByName(identifier, use);
-    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 = idMap?.get(id)?.content;
-                if (value !== undefined) {
-                    values.push(value);
-                }
-            }
-        }
-    }
-    if (values.length == 0) {
-        return undefined;
-    }
-    return values;
-}
-function isNestedInLoop(node, ast) {
-    const parent = node?.info.parent;
-    if (node === undefined || !parent) {
-        return false;
-    }
-    const parentNode = ast.get(parent);
-    if (parentNode === undefined) {
-        return false;
-    }
-    if (parentNode.type === type_1.RType.WhileLoop || parentNode.type === type_1.RType.RepeatLoop) {
-        return true;
-    }
-    return isNestedInLoop(parentNode, 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);
-    queue.add(id, clean, cleanFingerprint, false);
-    let forceBot = false;
-    const resultIds = [];
-    while (queue.nonEmpty()) {
-        const { id, baseEnvironment } = queue.next();
-        const res = graph.get(id);
-        if (!res) {
-            continue;
-        }
-        const [vertex, outgoingEdges] = res;
-        const cds = vertex.cds;
-        for (const cd of cds ?? []) {
-            const target = graph.idMap?.get(cd.id);
-            if (target === undefined) {
-                continue;
-            }
-            if (target.type === type_1.RType.WhileLoop || target.type === type_1.RType.RepeatLoop) {
-                forceBot = true;
-                break;
-            }
-        }
-        if (!forceBot && (cds?.length === 0 && isNestedInLoop(idMap.get(id), idMap))) {
-            forceBot = true;
-        }
-        if (forceBot) {
-            break;
-        }
-        if (vertex.tag === vertex_1.VertexType.Value) {
-            resultIds.push(id);
-            continue;
-        }
-        else if (vertex.tag === vertex_1.VertexType.FunctionDefinition) {
-            resultIds.push(id);
-            continue;
-        }
-        const isFn = vertex.tag === vertex_1.VertexType.FunctionCall;
-        // travel all read and defined-by edges
-        for (const [targetId, edge] of outgoingEdges) {
-            if (isFn) {
-                if (edge.types === edge_1.EdgeType.Returns || edge.types === edge_1.EdgeType.DefinedByOnCall || edge.types === edge_1.EdgeType.DefinedBy) {
-                    queue.add(targetId, baseEnvironment, cleanFingerprint, false);
-                }
-                continue;
-            }
-            // currently, they have to be exact!
-            if (edge.types === edge_1.EdgeType.Reads || edge.types === edge_1.EdgeType.DefinedBy || edge.types === edge_1.EdgeType.DefinedByOnCall) {
-                queue.add(targetId, baseEnvironment, cleanFingerprint, false);
-            }
-        }
-    }
-    if (forceBot || resultIds.length === 0) {
-        return undefined;
-    }
-    const values = [];
-    for (const id of resultIds) {
-        const node = idMap.get(id);
-        if (node !== undefined) {
-            values.push(node.content);
-        }
-    }
-    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
- *
- * @see {@link resolveIdToValue} - for a more general approach which "evaluates" a node based on value resolve
- */
-function resolveValueOfVariable(identifier, environment, idMap) {
-    const resolve = (0, config_1.getConfig)().solver.variables;
-    switch (resolve) {
-        case config_1.VariableResolve.Alias: return trackAliasInEnvironments(identifier, environment, idMap);
-        case config_1.VariableResolve.Builtin: return resolveToConstants(identifier, environment);
-        case config_1.VariableResolve.Disabled: return [];
-        default: (0, assert_1.assertUnreachable)(resolve);
-    }
-}
-/**
- * Generalized {@link resolveValueOfVariable} function which evaluates a node based on the value resolve
- *
- * @param id          - The node id or node to resolve
- * @param environment - The current environment used for name resolution
- * @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 variables
- */
-function resolveIdToValue(id, { environment, graph, idMap, full }) {
-    idMap ??= graph?.idMap;
-    const node = typeof id === 'object' ? id : idMap?.get(id);
-    if (node === undefined) {
-        return undefined;
-    }
-    switch (node.type) {
-        case type_1.RType.Symbol:
-            if (environment) {
-                return full ? resolveValueOfVariable(node.lexeme, environment, idMap) : undefined;
-            }
-            else if (graph && (0, config_1.getConfig)().solver.variables === config_1.VariableResolve.Alias) {
-                return full ? trackAliasesInGraph(node.info.id, graph, idMap) : undefined;
-            }
-            else {
-                return undefined;
-            }
-        case type_1.RType.String:
-        case type_1.RType.Number:
-        case type_1.RType.Logical:
-            return [node.content];
-        default:
-            return undefined;
-    }
-}
 //# sourceMappingURL=resolve-by-name.js.map

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

@@ -0,0 +1,92 @@
+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';
+import type { Identifier } from '../../environments/identifier';
+import type { DataflowGraph } from '../../graph/graph';
+import type { Lift, Value, ValueSet } from '../values/r-value';
+export type ResolveResult = Lift<ValueSet<Value[]>>;
+export interface ResolveInfo {
+    /** The current environment used for name resolution */
+    environment?: REnvironmentInformation;
+    /** The id map to resolve the node if given as an id */
+    idMap?: AstIdMap;
+    /** The graph to resolve in */
+    graph?: DataflowGraph;
+    /** Whether to track variables */
+    full?: boolean;
+    /** Variable resolve mode */
+    resolve: VariableResolve;
+}
+/**
+ * Gets the definitions / aliases of a node
+ *
+ * This function is called by the built-in-assignment processor so that we can
+ * track assignments inside the environment. The returned ids are stored in
+ * the sourceIds value field of their InGraphIdentifierDefinition. This enables
+ * us later, in the {@link trackAliasInEnvironments} function, to get all the
+ * aliases of an identifier.
+ *
+ * @param sourceIds    - node ids to get the definitions for
+ * @param dataflow     - dataflow graph
+ * @param environment  - environment
+ * @returns node id of alias
+ */
+export declare function getAliases(sourceIds: readonly NodeId[], dataflow: DataflowGraph, environment: REnvironmentInformation): NodeId[] | undefined;
+/**
+ * Evaluates the value of a node in the set domain.
+ *
+ * resolveIdToValue tries to resolve the value using the data it has been given.
+ * If the environment is provided the approximation is more precise, as we can
+ * track aliases in the environment.
+ * Otherwise, the graph is used to try and resolve the nodes value.
+ * If neither is provided the value cannot be resolved.
+ *
+ * This function is also used by the Resolve Value Query and the Dependency Query
+ * to resolve values. For e.g. in the Dependency Query it is used to resolve calls
+ * like `lapply(c("a", "b", "c"), library, character.only = TRUE)`
+ *
+ * @param id          - The node id or node to resolve
+ * @param environment - The current environment used for name resolution
+ * @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, resolve }: ResolveInfo): ResolveResult;
+/**
+ * Please use {@link resolveIdToValue}
+ *
+ * Uses the aliases that were tracked in the environments (by the
+ * {@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(resolve: VariableResolve, identifier: Identifier | undefined, use: REnvironmentInformation, graph?: DataflowGraph, idMap?: AstIdMap): ResolveResult;
+/**
+ * Please use {@link resolveIdToValue}
+ *
+ * Tries to resolve the value of a node by traversing the dataflow graph
+ *
+ * @param id    - node to resolve
+ * @param graph - dataflow graph
+ * @param idMap - idmap of dataflow graph
+ * @returns Value of node or Top/Bottom
+ */
+export declare function trackAliasesInGraph(id: NodeId, graph: DataflowGraph, idMap?: AstIdMap): ResolveResult;
+/**
+ * Please use {@link resolveIdToValue}
+ *
+ * Resolve an Identifier to a constant, if the identifier is a constant
+ *
+ * @param name        - Identifier to resolve
+ * @param environment - Environment to use
+ * @returns Value of Constant or Top
+ */
+export declare function resolveToConstants(name: Identifier | undefined, environment: REnvironmentInformation): ResolveResult;