@eagleoutice/flowr 2.2.16 → 2.4.0

package/dataflow/environments/built-in.js

@@ -41,30 +41,31 @@ function builtInId(name) {
 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: config.useAsProcessor ?? 'builtin:default' });
-    if (config.returnsNthArgument !== undefined) {
-        const arg = config.returnsNthArgument === 'last' ? processedArguments[args.length - 1] : processedArguments[config.returnsNthArgument];
+function defaultBuiltInProcessor(name, args, rootId, data, { returnsNthArgument, useAsProcessor, forceArgs, readAllArguments, cfg, hasUnknownSideEffects, treatAsFnCall }) {
+    const activeProcessor = useAsProcessor ?? 'builtin:default';
+    const { information: res, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs, origin: activeProcessor });
+    if (returnsNthArgument !== undefined) {
+        const arg = returnsNthArgument === 'last' ? processedArguments[args.length - 1] : processedArguments[returnsNthArgument];
         if (arg !== undefined) {
             res.graph.addEdge(rootId, arg.entryPoint, edge_1.EdgeType.Returns);
         }
     }
-    if (config.readAllArguments) {
+    if (readAllArguments) {
         for (const arg of processedArguments) {
             if (arg) {
                 res.graph.addEdge(rootId, arg.entryPoint, edge_1.EdgeType.Reads);
             }
         }
     }
-    if (config.hasUnknownSideEffects) {
-        if (typeof config.hasUnknownSideEffects !== 'boolean') {
-            (0, unknown_side_effect_1.handleUnknownSideEffect)(res.graph, res.environment, rootId, config.hasUnknownSideEffects);
+    if (hasUnknownSideEffects) {
+        if (typeof hasUnknownSideEffects !== 'boolean') {
+            (0, unknown_side_effect_1.handleUnknownSideEffect)(res.graph, res.environment, rootId, hasUnknownSideEffects);
         }
         else {
             (0, unknown_side_effect_1.handleUnknownSideEffect)(res.graph, res.environment, rootId);
         }
     }
-    const fnCallNames = config.treatAsFnCall?.[name.content];
+    const fnCallNames = treatAsFnCall?.[name.content];
     if (fnCallNames) {
         for (const arg of args) {
             if (arg !== r_function_call_1.EmptyArgument && arg.value && fnCallNames.includes(arg.name?.content)) {
@@ -90,13 +91,13 @@ function defaultBuiltInProcessor(name, args, rootId, data, config) {
                     environment: data.environment,
                     onlyBuiltin: false,
                     cds: data.controlDependencies,
-                    origin: [config.useAsProcessor ?? 'builtin:default']
+                    origin: [activeProcessor]
                 });
             }
         }
     }
-    if (config.cfg !== undefined) {
-        res.exitPoints = [...res.exitPoints, { type: config.cfg, nodeId: rootId, controlDependencies: data.controlDependencies }];
+    if (cfg !== undefined) {
+        res.exitPoints.push({ type: cfg, nodeId: rootId, controlDependencies: data.controlDependencies });
     }
     return res;
 }
@@ -144,7 +145,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/eval/resolve/alias-tracking.js

@@ -139,6 +139,8 @@ function resolveIdToValue(id, { environment, graph, idMap, full = true, resolve
                 return r_value_1.Top;
             }
         case type_1.RType.FunctionCall:
+        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:
@@ -261,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.d.ts

@@ -1,7 +1,8 @@
 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
@@ -22,16 +23,59 @@ export declare function resolveNode(resolve: VariableResolve, a: RNodeWithParent
  * Helper function used by {@link resolveIdToValue}, please use that instead, if
  * you want to resolve the value of an identifier / node
  *
- * This function converts an r-node to a Value Vector {@link vectorFrom}
- * It also recursively 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 resolve - Variable resolve mode
+ * @param node    - Node of the vector function to resolve
+ * @param env     - Environment to use
  * @param graph   - Dataflow graph
- * @param map     - Idmap of Dataflow Graph
+ * @param map     - Id map of the dataflow graph
  * @returns ValueVector or Top
  */
-export declare function resolveAsVector(resolve: VariableResolve, 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;

package/dataflow/eval/resolve/resolve.js

@@ -2,17 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveNode = resolveNode;
 exports.resolveAsVector = resolveAsVector;
+exports.resolveAsSeq = resolveAsSeq;
+exports.resolveAsPlus = resolveAsPlus;
+exports.resolveAsMinus = resolveAsMinus;
 const r_function_call_1 = require("../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const type_1 = require("../../../r-bridge/lang-4.x/ast/model/type");
-const assert_1 = require("../../../util/assert");
+const r_value_1 = require("../../../util/r-value");
 const built_in_1 = require("../../environments/built-in");
 const dfg_get_origin_1 = require("../../origin/dfg-get-origin");
 const interval_constants_1 = require("../values/intervals/interval-constants");
 const logical_constants_1 = require("../values/logical/logical-constants");
-const r_value_1 = require("../values/r-value");
+const r_value_2 = require("../values/r-value");
 const string_constants_1 = require("../values/string/string-constants");
 const vector_constants_1 = require("../values/vectors/vector-constants");
 const alias_tracking_1 = require("./alias-tracking");
+const scalar_consatnts_1 = require("../values/scalar/scalar-consatnts");
 /**
  * Helper function used by {@link resolveIdToValue}, please use that instead, if
  * you want to resolve the value of an identifier / node
@@ -37,59 +41,149 @@ function resolveNode(resolve, a, env, graph, map) {
     else if (a.type === type_1.RType.Logical) {
         return a.content.valueOf() ? logical_constants_1.ValueLogicalTrue : logical_constants_1.ValueLogicalFalse;
     }
-    else if (a.type === type_1.RType.FunctionCall && env && graph) {
+    else if ((a.type === type_1.RType.FunctionCall || a.type === type_1.RType.BinaryOp || a.type === type_1.RType.UnaryOp) && graph) {
         const origin = (0, dfg_get_origin_1.getOriginInDfg)(graph, a.info.id)?.[0];
         if (origin === undefined || origin.type !== 3 /* OriginType.BuiltInFunctionOrigin */) {
-            return r_value_1.Top;
+            return r_value_2.Top;
         }
-        if (origin.proc in built_in_1.BuiltInEvalHandlerMapper) {
-            const handler = built_in_1.BuiltInEvalHandlerMapper[origin.proc];
+        let builtInName;
+        if ((0, built_in_1.isBuiltIn)(origin.proc)) {
+            builtInName = origin.proc;
+        }
+        else if (a.type === type_1.RType.FunctionCall && a.named) {
+            builtInName = (0, built_in_1.builtInId)(a.functionName.content);
+        }
+        else if (a.type === type_1.RType.BinaryOp || a.type === type_1.RType.UnaryOp) {
+            builtInName = (0, built_in_1.builtInId)(a.operator);
+        }
+        else {
+            return r_value_2.Top;
+        }
+        if (Object.prototype.hasOwnProperty.call(built_in_1.BuiltInEvalHandlerMapper, builtInName)) {
+            const handler = built_in_1.BuiltInEvalHandlerMapper[builtInName];
             return handler(resolve, a, env, graph, map);
         }
     }
-    return r_value_1.Top;
+    return r_value_2.Top;
 }
 /**
  * Helper function used by {@link resolveIdToValue}, please use that instead, if
  * you want to resolve the value of an identifier / node
  *
- * This function converts an r-node to a Value Vector {@link vectorFrom}
- * It also recursively 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 resolve - Variable resolve mode
+ * @param node    - Node of the vector function to resolve
+ * @param env     - Environment to use
  * @param graph   - Dataflow graph
- * @param map     - Idmap of Dataflow Graph
+ * @param map     - Id map of the dataflow graph
  * @returns ValueVector or Top
  */
-function resolveAsVector(resolve, a, env, graph, map) {
-    (0, assert_1.guard)(a.type === type_1.RType.FunctionCall);
-    const values = [];
-    for (const arg of a.arguments) {
-        if (arg === r_function_call_1.EmptyArgument) {
-            continue;
-        }
-        if (arg.value === undefined) {
-            return r_value_1.Top;
-        }
-        if (arg.value.type === type_1.RType.Symbol) {
-            const value = (0, alias_tracking_1.resolveIdToValue)(arg.info.id, { environment: env, idMap: map, graph: graph, full: true, resolve });
-            if ((0, r_value_1.isTop)(value)) {
-                return r_value_1.Top;
-            }
-            values.push(value);
-        }
-        else {
-            const val = resolveNode(resolve, arg.value, env, graph, map);
-            if ((0, r_value_1.isTop)(val)) {
-                return r_value_1.Top;
-            }
-            values.push(val);
-        }
+function resolveAsVector(resolve, node, environment, graph, idMap) {
+    if (node.type !== type_1.RType.FunctionCall) {
+        return r_value_2.Top;
     }
+    const resolveInfo = { environment, graph, idMap, full: true, resolve };
+    const values = node.arguments.map(arg => arg !== r_function_call_1.EmptyArgument ? (0, alias_tracking_1.resolveIdToValue)(arg.value, resolveInfo) : r_value_2.Top);
     return (0, vector_constants_1.vectorFrom)((0, vector_constants_1.flattenVectorElements)(values));
 }
+/**
+ * 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
+ */
+function resolveAsSeq(resolve, operator, environment, graph, idMap) {
+    if (operator.type !== type_1.RType.BinaryOp) {
+        return r_value_2.Top;
+    }
+    const resolveInfo = { environment, graph, idMap, full: true, resolve };
+    const leftArg = (0, alias_tracking_1.resolveIdToValue)(operator.lhs, resolveInfo);
+    const rightArg = (0, alias_tracking_1.resolveIdToValue)(operator.rhs, resolveInfo);
+    const leftValue = (0, r_value_1.unliftRValue)(leftArg);
+    const rightValue = (0, r_value_1.unliftRValue)(rightArg);
+    if ((0, r_value_1.isRNumberValue)(leftValue) && (0, r_value_1.isRNumberValue)(rightValue)) {
+        return (0, vector_constants_1.vectorFrom)(createNumberSequence(leftValue, rightValue).map(scalar_consatnts_1.liftScalar));
+    }
+    return r_value_2.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
+ */
+function resolveAsPlus(resolve, operator, environment, graph, idMap) {
+    if (operator.type !== type_1.RType.UnaryOp) {
+        return r_value_2.Top;
+    }
+    const resolveInfo = { environment, graph, idMap, full: true, resolve };
+    const arg = (0, alias_tracking_1.resolveIdToValue)(operator.operand, resolveInfo);
+    const argValue = (0, r_value_1.unliftRValue)(arg);
+    if ((0, r_value_1.isRNumberValue)(argValue)) {
+        return (0, scalar_consatnts_1.liftScalar)(argValue);
+    }
+    else if (Array.isArray(argValue) && argValue.every(r_value_1.isRNumberValue)) {
+        return (0, vector_constants_1.vectorFrom)(argValue.map(scalar_consatnts_1.liftScalar));
+    }
+    return r_value_2.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
+ */
+function resolveAsMinus(resolve, operator, environment, graph, idMap) {
+    if (operator.type !== type_1.RType.UnaryOp) {
+        return r_value_2.Top;
+    }
+    const resolveInfo = { environment, graph, idMap, full: true, resolve };
+    const arg = (0, alias_tracking_1.resolveIdToValue)(operator.operand, resolveInfo);
+    const argValue = (0, r_value_1.unliftRValue)(arg);
+    if ((0, r_value_1.isRNumberValue)(argValue)) {
+        return (0, scalar_consatnts_1.liftScalar)({ ...argValue, num: -argValue.num });
+    }
+    else if (Array.isArray(argValue) && argValue.every(r_value_1.isRNumberValue)) {
+        return (0, vector_constants_1.vectorFrom)(argValue.map(element => (0, scalar_consatnts_1.liftScalar)({ ...element, num: -element.num })));
+    }
+    return r_value_2.Top;
+}
+function createNumberSequence(start, end) {
+    const sequence = [];
+    const min = Math.min(start.num, end.num);
+    const max = Math.max(start.num, end.num);
+    for (let i = min; i <= max; i++) {
+        sequence.push({ ...start, num: i });
+    }
+    if (start > end) {
+        sequence.reverse();
+    }
+    return sequence;
+}
 //# sourceMappingURL=resolve.js.map

package/dataflow/graph/dataflowgraph-builder.js

@@ -180,7 +180,7 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
             fromId = from.nodeId;
         }
         else {
-            const result = (0, flowr_search_executor_1.runSearch)(from.query, data);
+            const result = (0, flowr_search_executor_1.runSearch)(from.query, data).getElements();
             (0, assert_1.guard)(result.length === 1, `from query result should yield exactly one node, but yielded ${result.length}`);
             fromId = result[0].node.info.id;
         }
@@ -189,7 +189,7 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
             toIds = to.target;
         }
         else {
-            const result = (0, flowr_search_executor_1.runSearch)(to.query, data);
+            const result = (0, flowr_search_executor_1.runSearch)(to.query, data).getElements();
             toIds = result.map(r => r.node.info.id);
         }
         return this.edgeHelper(fromId, toIds, type);

package/dataflow/graph/graph.js

@@ -376,7 +376,7 @@ function mergeNodeInfos(current, next) {
     }
     else if (current.tag === vertex_1.VertexType.FunctionDefinition) {
         (0, assert_1.guard)(current.scope === next.scope, 'nodes to be joined for the same id must have the same scope');
-        (0, assert_1.guard)((0, arrays_1.arrayEqual)(current.exitPoints, next.exitPoints), 'nodes to be joined must have same exist points');
+        current.exitPoints = (0, arrays_1.uniqueArrayMerge)(current.exitPoints, next.exitPoints);
     }
     return current;
 }

package/dataflow/graph/invert-dfg.d.ts

@@ -0,0 +1,2 @@
+import { DataflowGraph } from './graph';
+export declare function invertDfg(graph: DataflowGraph): DataflowGraph;

package/dataflow/graph/invert-dfg.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invertDfg = invertDfg;
+const graph_1 = require("./graph");
+function invertDfg(graph) {
+    const invertedGraph = new graph_1.DataflowGraph(graph.idMap);
+    for (const [, v] of graph.vertices(true)) {
+        invertedGraph.addVertex(v);
+    }
+    for (const [from, targets] of graph.edges()) {
+        for (const [to, { types }] of targets) {
+            invertedGraph.addEdge(to, from, types);
+        }
+    }
+    return invertedGraph;
+}
+//# sourceMappingURL=invert-dfg.js.map

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

@@ -8,6 +8,7 @@ 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 { NoInfo } from '../../../../../../r-bridge/lang-4.x/ast/model/model';
+export declare function getSourceProvider(): RParseRequestProvider;
 export declare function setSourceProvider(provider: RParseRequestProvider): void;
 export declare function inferWdFromScript(option: InferWorkingDirectory, referenceChain: readonly RParseRequest[]): string[];
 /**

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

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSourceProvider = getSourceProvider;
 exports.setSourceProvider = setSourceProvider;
 exports.inferWdFromScript = inferWdFromScript;
 exports.findSource = findSource;
@@ -30,6 +31,9 @@ const r_value_1 = require("../../../../../eval/values/r-value");
 const unknown_side_effect_1 = require("../../../../../graph/unknown-side-effect");
 const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
 let sourceProvider = (0, retriever_1.requestProviderFromFile)();
+function getSourceProvider() {
+    return sourceProvider;
+}
 function setSourceProvider(provider) {
     sourceProvider = provider;
 }

package/documentation/doc-util/doc-query.js

@@ -17,6 +17,7 @@ const doc_dfg_1 = require("./doc-dfg");
 const doc_code_1 = require("./doc-code");
 const time_1 = require("../../util/text/time");
 const query_print_1 = require("../../queries/query-print");
+const doc_cli_option_1 = require("./doc-cli-option");
 const config_1 = require("../../config");
 async function showQuery(shell, code, queries, { showCode, collapseResult, collapseQuery, addOutput = () => '' } = {}) {
     const now = performance.now();
@@ -24,7 +25,7 @@ async function showQuery(shell, code, queries, { showCode, collapseResult, colla
         parser: shell,
         request: (0, retriever_1.requestFromInput)(code)
     }, config_1.defaultConfigOptions).allRemainingSteps();
-    const results = (0, query_1.executeQueries)({ dataflow: analysis.dataflow, ast: analysis.normalize, config: config_1.defaultConfigOptions }, queries);
+    const results = await Promise.resolve((0, query_1.executeQueries)({ dataflow: analysis.dataflow, ast: analysis.normalize, config: config_1.defaultConfigOptions }, queries));
     const duration = performance.now() - now;
     const metaInfo = `
 The analysis required _${(0, time_1.printAsMs)(duration)}_ (including parsing and normalization and the query) within the generation environment.
@@ -34,6 +35,15 @@ The analysis required _${(0, time_1.printAsMs)(duration)}_ (including parsing an
 
 ${(0, doc_code_1.codeBlock)('json', collapseQuery ? str.split('\n').join(' ').replace(/([{[])\s{2,}/g, '$1 ').replace(/\s{2,}([\]}])/g, ' $1') : str)}
 
+${(function () {
+        if (queries.length === 1 && Object.keys(queries[0]).length === 1) {
+            return `(This query can be shortened to \`@${queries[0].type}\` when used within the REPL command ${(0, doc_cli_option_1.getReplCommand)('query')}).`;
+        }
+        else {
+            return '';
+        }
+    })()}
+
 ${collapseResult ? ' <details> <summary style="color:gray">Show Results</summary>' : ''}
 
 _Results (prettified and summarized):_

package/documentation/doc-util/doc-search.js

@@ -53,13 +53,13 @@ ${(0, doc_code_1.codeBlock)('json', JSON.stringify(search, null, 2))}
 ${collapseResult ? ' <details> <summary style="color:gray">Show Results</summary>' : ''}
 
 The query returns the following vetices (all references to \`x\` in the code):
-${result.map(({ node }) => `<b>${node.info.id} ('${(0, node_id_1.recoverContent)(node.info.id, analysis.dataflow.graph)}')</b> at L${(0, dfg_1.formatRange)(node.location)}`).join(', ')}
+${result.getElements().map(({ node }) => `<b>${node.info.id} ('${(0, node_id_1.recoverContent)(node.info.id, analysis.dataflow.graph)}')</b> at L${(0, dfg_1.formatRange)(node.location)}`).join(', ')}
 
 ${metaInfo}	
 
 The returned results are highlighted thick and blue within the dataflow graph:
 
-${await (0, doc_dfg_1.printDfGraphForCode)(shell, code, { showCode: false, switchCodeAndGraph: false, mark: new Set(result.map(({ node }) => node.info.id)) })}
+${await (0, doc_dfg_1.printDfGraphForCode)(shell, code, { showCode: false, switchCodeAndGraph: false, mark: new Set(result.getElements().map(({ node }) => node.info.id)) })}
 
 
 ${collapseResult ? '</details>' : ''}

package/documentation/print-cfg-wiki.js

@@ -224,8 +224,7 @@ ${Object.entries(control_flow_graph_1.CfgVertexType).map(([key, value]) => `- \`
 We use the ${(0, doc_types_1.shortLink)('CfgBasicBlockVertex', types.info)} to represent [basic blocks](#cfg-basic-blocks) and separate
 expressions (${(0, doc_types_1.shortLink)('CfgExpressionVertex', types.info)}) and statements (${(0, doc_types_1.shortLink)('CfgStatementVertex', types.info)}) 
 as control flow units with and without side effects (if you want to, you can see view statements as effectful expressions).
-The markers (${(0, doc_types_1.shortLink)('CfgMidMarkerVertex', types.info)} and ${(0, doc_types_1.shortLink)('CfgEndMarkerVertex', types.info)})
-indicate specific segments of larger expressions/statements (e.g., an \`if\` which has a condition and its branches). 
+The markers (${(0, doc_types_1.shortLink)('CfgEndMarkerVertex', types.info)}) indicate the end of larger expressions/statements. 
 
 To signal these links, the expressions and statements contain information about the attached markers:
 
@@ -235,7 +234,7 @@ Similarly, the markers contain a link to their root:
 
 ${(0, doc_types_1.printHierarchy)({ info: types.info, root: 'CfgWithRoot', program: types.program, openTop: true })}
 
-In mermaid visualizations, we use rectangles for statements, rounded rectangles for expressions, circles for exit markers and double-lined rectangles for mid markers.
+In mermaid visualizations, we use rectangles for statements, rounded rectangles for expressions and circles for exit markers.
 Blocks are visualized as boxes around the contained vertices.
 
 ${(0, doc_structure_1.block)({
@@ -554,7 +553,7 @@ Hence, you may rely on the corresponding exit point(s) to identify all exits of
 
 ${(0, doc_structure_1.block)({
         type: 'WARNING',
-        content: 'Using basic blocks, this works just the same. However please keep in mind that the corresponding exit markers do not (and for control statements usually will not) be part of the same basic block.'
+        content: 'Using basic blocks, this works just the same. However, please keep in mind that the corresponding exit markers do not (and for control statements usually will not) be part of the same basic block.'
     })}
 
 `;

package/documentation/print-core-wiki.js

@@ -28,7 +28,6 @@ const built_in_access_1 = require("../dataflow/internal/process/functions/call/b
 const built_in_for_loop_1 = require("../dataflow/internal/process/functions/call/built-in/built-in-for-loop");
 const built_in_repeat_loop_1 = require("../dataflow/internal/process/functions/call/built-in/built-in-repeat-loop");
 const linker_1 = require("../dataflow/internal/linker");
-const static_slicer_1 = require("../slicing/static/static-slicer");
 const info_1 = require("../dataflow/info");
 const processor_1 = require("../dataflow/processor");
 const default_pipelines_1 = require("../core/steps/pipeline/default-pipelines");
@@ -42,6 +41,7 @@ const normalize_for_1 = require("../r-bridge/lang-4.x/ast/parser/main/internal/l
 const doc_issue_1 = require("./doc-util/doc-issue");
 const pipeline_executor_1 = require("../core/pipeline-executor");
 const pipeline_1 = require("../core/steps/pipeline/pipeline");
+const static_slicer_1 = require("../slicing/static/static-slicer");
 const config_1 = require("../config");
 async function getText(shell) {
     const rversion = (await shell.usedRVersion())?.format() ?? 'unknown';
@@ -373,7 +373,7 @@ Of course, all of these endeavors work not just with the ${(0, doc_types_1.short
 The slicing is available as an extra step as you can see by inspecting he ${(0, doc_types_1.shortLink)('DEFAULT_SLICING_PIPELINE', info)}.
 Besides ${(0, doc_types_1.shortLink)('STATIC_SLICE', info)} it contains a ${(0, doc_types_1.shortLink)('NAIVE_RECONSTRUCT', info)} to print the slice as (executable) R code.
 
-Your main point of interesting here is the ${(0, doc_types_1.shortLink)(static_slicer_1.staticSlicing.name, info)} function which relies on a modified
+Your main point of interesting here is the ${(0, doc_types_1.shortLink)(static_slicer_1.staticSlice.name, info)} function which relies on a modified
 breadth-first search to collect all nodes which are part of the slice. 
 For more information on how the slicing works, please refer to the [tool demonstration (Section 3.2)](https://doi.org/10.1145/3691620.3695359),
 or the [original master's thesis (Chapter 4)](https://doi.org/10.18725/OPARU-50107).

package/documentation/print-dataflow-graph-wiki.js

@@ -835,6 +835,13 @@ The following sections present details on the different types of vertices and ed
 ${(0, doc_general_1.prefixLines)((0, doc_code_1.codeBlock)('ts', 'const node = graph.idMap.get(id);'), '> ')}
 > In case you just need the name (\`lexeme\`) of the respective vertex, ${(0, doc_types_1.shortLink)(node_id_1.recoverName.name, vertexType.info)} can help you out:
 ${(0, doc_general_1.prefixLines)((0, doc_code_1.codeBlock)('ts', `const name = ${node_id_1.recoverName.name}(id, graph.idMap);`), '> ')}
+>
+> Please note that not every node in the normalized AST is represented in the dataflow graph.
+> For example, if the node is unreachable in a way that can be detected during the analysis and flowR
+> is configured to ignore dead code. Likewise, empty argument wrappers do not have a corresponding
+> dataflow graph vertex (as they are not relevant for the dataflow graph). It depends on the scenario what to do in such a case. 
+> For argument wrappers you can access the dataflow information for their value. For dead code, however, flowR currently contains
+> some core heuristics that remove it which cannot be reversed easily. So please open [an issue](${doc_issue_1.NewIssueUrl}) if you encounter such a case and require the node to be present in the dataflow graph.
 
 ${(0, doc_structure_1.section)('Vertices', 2, 'vertices')}
 

package/documentation/print-faq-wiki.js

@@ -39,6 +39,10 @@ With \`npm\` you have to pass arguments in a specific way. The \`--\` operator i
 ${(0, doc_code_1.codeBlock)('shell', 'npm run flowR -- --help')}
 `)}
 
+${qAndA('How to do logging in flowR?', `
+Check out the [Logging Section in the Linting and Testing wiki page](${doc_files_1.FlowrWikiBaseRef}/Linting-and-Testing#logging) for more information on how to do logging in *flowR*.
+`)}
+
 ## 🇷 R FAQ
 
 ### 📦 R Packages

package/documentation/print-interface-wiki.js

@@ -182,6 +182,7 @@ The following summarizes the configuration options:
 - \`solver\`: allows to configure how _flowR_ resolves variables and their values (currently we support: ${Object.values(config_1.VariableResolve).map(v => `\`${v}\``).join(', ')}), as well as if pointer analysis should be active.
 - \`engines\`: allows to configure the engines used by _flowR_ to interact with R code. See the [Engines wiki page](${doc_files_1.FlowrWikiBaseRef}/Engines) for more information.
 - \`defaultEngine\`: allows to specify the default engine to use for interacting with R code. If not set, an arbitrary engine from the specified list will be used.
+- \`abstractInterpretation\`: allows to configure how _flowR_ performs abstract interpretation, although we currently only support data frame shape inference through abstract interpretation.
 
 So you can configure _flowR_ by adding a file like the following:
 
@@ -214,6 +215,16 @@ ${(0, doc_code_1.codeBlock)('json', JSON.stringify({
             slicer: {
                 threshold: 50
             }
+        },
+        abstractInterpretation: {
+            dataFrame: {
+                maxColNames: 20,
+                wideningThreshold: 4,
+                readLoadedData: {
+                    readExternalFiles: true,
+                    maxReadLines: 1_000_000
+                }
+            }
         }
     }, null, 2))}