@eagleoutice/flowr 2.4.7 → 2.5.0

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

@@ -21,6 +21,7 @@ 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");
+const r_value_1 = require("../../../../../eval/values/r-value");
 function toReplacementSymbol(target, prefix, superAssignment) {
     return {
         type: type_1.RType.Symbol,
@@ -87,18 +88,57 @@ args, rootId, data, config) {
         return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs, origin: 'default' }).information;
     }
     const { type, named } = target;
-    if (!config.targetVariable && type === type_1.RType.Symbol) {
-        const res = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, reverseOrder: !config.swapSourceAndTarget, forceArgs: config.forceArgs, origin: 'builtin:assignment' });
-        return processAssignmentToSymbol({
-            ...config,
-            nameOfAssignmentFunction: name.content,
-            source,
-            target,
-            args: getEffectiveOrder(config, res.processedArguments),
-            rootId,
-            data,
-            information: res.information,
-        });
+    if (type === type_1.RType.Symbol) {
+        if (!config.targetVariable) {
+            const res = (0, known_call_handling_1.processKnownFunctionCall)({
+                name,
+                args,
+                rootId,
+                data,
+                reverseOrder: !config.swapSourceAndTarget,
+                forceArgs: config.forceArgs,
+                origin: 'builtin:assignment'
+            });
+            return processAssignmentToSymbol({
+                ...config,
+                nameOfAssignmentFunction: name.content,
+                source,
+                targetId: target.info.id,
+                args: getEffectiveOrder(config, res.processedArguments),
+                rootId,
+                data,
+                information: res.information,
+            });
+        }
+        else {
+            // try to resolve the variable first
+            const n = (0, alias_tracking_1.resolveIdToValue)(target.info.id, { environment: data.environment, resolve: data.flowrConfig.solver.variables, idMap: data.completeAst.idMap, full: true });
+            if (n.type === 'set' && n.elements.length === 1 && n.elements[0].type === 'string') {
+                const val = n.elements[0].value;
+                if ((0, r_value_1.isValue)(val)) {
+                    const res = (0, known_call_handling_1.processKnownFunctionCall)({
+                        name,
+                        args,
+                        rootId,
+                        data,
+                        reverseOrder: !config.swapSourceAndTarget,
+                        forceArgs: config.forceArgs,
+                        origin: 'builtin:assignment'
+                    });
+                    return processAssignmentToSymbol({
+                        ...config,
+                        nameOfAssignmentFunction: name.content,
+                        source,
+                        targetId: target.info.id,
+                        targetName: val.str,
+                        args: getEffectiveOrder(config, res.processedArguments),
+                        rootId,
+                        data,
+                        information: res.information,
+                    });
+                }
+            }
+        }
     }
     else if (config.canBeReplacement && type === type_1.RType.FunctionCall && named) {
         /* as replacement functions take precedence over the lhs fn-call (i.e., `names(x) <- ...` is independent from the definition of `names`), we do not have to process the call */
@@ -127,7 +167,7 @@ args, rootId, data, config) {
                 ...config,
                 nameOfAssignmentFunction: name.content,
                 source,
-                target: rootArg,
+                targetId: rootArg.info.id,
                 args: getEffectiveOrder(config, res.processedArguments),
                 rootId,
                 data,
@@ -155,12 +195,12 @@ function extractSourceAndTarget(args) {
  * Promotes the ingoing/unknown references of target (an assignment) to definitions
  */
 function produceWrittenNodes(rootId, target, referenceType, data, makeMaybe, value) {
-    return [...target.in, ...target.unknownReferences].map(ref => ({
+    return target.in.concat(target.unknownReferences).map(ref => ({
         ...ref,
         type: referenceType,
         definedAt: rootId,
         controlDependencies: data.controlDependencies ?? (makeMaybe ? [] : undefined),
-        value: value
+        value
     }));
 }
 function processAssignmentToString(target, args, name, rootId, data, config, source) {
@@ -190,7 +230,7 @@ function processAssignmentToString(target, args, name, rootId, data, config, sou
         ...config,
         nameOfAssignmentFunction: name.content,
         source,
-        target: symbol,
+        targetId: symbol.info.id,
         args: getEffectiveOrder(config, res.processedArguments),
         rootId,
         data,
@@ -269,19 +309,26 @@ function markAsAssignment(information, nodeToDefine, sourceIds, rootIdOfAssignme
  * Helper function whenever it is known that the _target_ of an assignment is a (single) symbol (i.e. `x <- ...`, but not `names(x) <- ...`).
  */
 function processAssignmentToSymbol(config) {
-    const { nameOfAssignmentFunction, source, args: [targetArg, sourceArg], target, rootId, data, information, makeMaybe, quoteSource } = config;
+    const { nameOfAssignmentFunction, source, args: [targetArg, sourceArg], targetId, targetName, rootId, data, information, makeMaybe, quoteSource } = config;
     const referenceType = checkTargetReferenceType(source, sourceArg);
     const aliases = (0, alias_tracking_1.getAliases)([source.info.id], information.graph, information.environment);
-    const writeNodes = produceWrittenNodes(rootId, targetArg, referenceType, data, makeMaybe ?? false, aliases);
+    const writeNodes = targetName ? [{
+            nodeId: targetId,
+            name: targetName,
+            type: referenceType,
+            definedAt: rootId,
+            controlDependencies: data.controlDependencies ?? (makeMaybe ? [] : undefined),
+            value: aliases
+        }]
+        : 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)}`);
     }
     // we drop the first arg which we use to pass along arguments :D
     const readFromSourceWritten = sourceArg.out.slice(1);
     const readTargets = [
-        { nodeId: rootId, name: nameOfAssignmentFunction, controlDependencies: data.controlDependencies, type: identifier_1.ReferenceType.Function },
-        ...sourceArg.unknownReferences, ...sourceArg.in, ...targetArg.in.filter(i => i.nodeId !== target.info.id), ...readFromSourceWritten
-    ];
+        { nodeId: rootId, name: nameOfAssignmentFunction, controlDependencies: data.controlDependencies, type: identifier_1.ReferenceType.Function }
+    ].concat(sourceArg.unknownReferences, sourceArg.in, targetName ? targetArg.in : targetArg.in.filter(i => i.nodeId !== targetId), readFromSourceWritten);
     information.environment = (0, overwrite_1.overwriteEnvironment)(sourceArg.environment, targetArg.environment);
     // install assigned variables in environment
     for (const write of writeNodes) {

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

@@ -181,8 +181,7 @@ function processExpressionList(name, args, rootId, data) {
         graph: nextGraph,
         /* if we have no group, we take the last evaluated expr */
         entryPoint: meId,
-        exitPoints: withGroup ? [{ nodeId: rootId, type: 0 /* ExitPointType.Default */, controlDependencies: data.controlDependencies }]
-            : exitPoints
+        exitPoints: exitPoints
     };
 }
 //# sourceMappingURL=built-in-expression-list.js.map

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

@@ -30,14 +30,13 @@ function processForLoop(name, args, rootId, data) {
     const variable = (0, processor_1.processDataflowFor)(variableArg, data);
     // this should not be able to exit always!
     const originalDependency = data.controlDependencies;
-    data = { ...data, controlDependencies: [...data.controlDependencies ?? [], { id: name.info.id, when: true }] };
     let headEnvironments = (0, overwrite_1.overwriteEnvironment)(vector.environment, variable.environment);
     const headGraph = variable.graph.mergeWith(vector.graph);
-    const writtenVariable = [...variable.unknownReferences, ...variable.in];
+    const writtenVariable = variable.unknownReferences.concat(variable.in);
     for (const write of writtenVariable) {
         headEnvironments = (0, define_1.define)({ ...write, definedAt: name.info.id, type: identifier_1.ReferenceType.Variable }, false, headEnvironments, data.flowrConfig);
     }
-    data = { ...data, environment: headEnvironments };
+    data = { ...data, controlDependencies: [...data.controlDependencies ?? [], { id: name.info.id, when: true }], environment: headEnvironments };
     const body = (0, processor_1.processDataflowFor)(bodyArg, data);
     const nextGraph = headGraph.mergeWith(body.graph);
     const outEnvironment = (0, append_1.appendEnvironment)(headEnvironments, body.environment);
@@ -48,8 +47,9 @@ function processForLoop(name, args, rootId, data) {
         nextGraph.addEdge(write.nodeId, vector.entryPoint, edge_1.EdgeType.DefinedBy);
         nextGraph.setDefinitionOfVertex(write);
     }
-    const outgoing = [...variable.out, ...writtenVariable, ...(0, environment_1.makeAllMaybe)(body.out, nextGraph, outEnvironment, true)];
+    const outgoing = variable.out.concat(writtenVariable, (0, environment_1.makeAllMaybe)(body.out, nextGraph, outEnvironment, true));
     (0, linker_1.linkCircularRedefinitionsWithinALoop)(nextGraph, nameIdShares, body.out);
+    (0, linker_1.reapplyLoopExitPoints)(body.exitPoints, body.in.concat(body.out, body.unknownReferences));
     (0, common_1.patchFunctionCall)({
         nextGraph,
         rootId,

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

@@ -28,7 +28,7 @@ function processIfThenElse(name, args, rootId, data) {
         logger_1.dataflowLogger.warn(`If-then-else ${rootId} forces exit in condition, skipping rest`);
         return cond;
     }
-    const originalDependency = data.controlDependencies;
+    const originalDependency = data.controlDependencies?.slice();
     // currently we update the cd afterward :sweat:
     data = { ...data, environment: cond.environment };
     let then;
@@ -73,21 +73,10 @@ function processIfThenElse(name, args, rootId, data) {
     const cdTrue = { id: rootId, when: true };
     const cdFalse = { id: rootId, when: false };
     // again within an if-then-else we consider all actives to be read
-    const ingoing = [
-        ...cond.in,
-        ...(makeThenMaybe ? (0, environment_1.makeAllMaybe)(then?.in, nextGraph, finalEnvironment, false, cdTrue) : then?.in ?? []),
-        ...(makeOtherwiseMaybe ? (0, environment_1.makeAllMaybe)(otherwise?.in, nextGraph, finalEnvironment, false, cdFalse) : otherwise?.in ?? []),
-        ...cond.unknownReferences,
-        ...(makeThenMaybe ? (0, environment_1.makeAllMaybe)(then?.unknownReferences, nextGraph, finalEnvironment, false, cdTrue) : then?.unknownReferences ?? []),
-        ...(makeOtherwiseMaybe ? (0, environment_1.makeAllMaybe)(otherwise?.unknownReferences, nextGraph, finalEnvironment, false, cdFalse) : otherwise?.unknownReferences ?? []),
-    ];
+    const ingoing = cond.in.concat(makeThenMaybe ? (0, environment_1.makeAllMaybe)(then?.in, nextGraph, finalEnvironment, false, cdTrue) : then?.in ?? [], makeOtherwiseMaybe ? (0, environment_1.makeAllMaybe)(otherwise?.in, nextGraph, finalEnvironment, false, cdFalse) : otherwise?.in ?? [], cond.unknownReferences, makeThenMaybe ? (0, environment_1.makeAllMaybe)(then?.unknownReferences, nextGraph, finalEnvironment, false, cdTrue) : then?.unknownReferences ?? [], makeOtherwiseMaybe ? (0, environment_1.makeAllMaybe)(otherwise?.unknownReferences, nextGraph, finalEnvironment, false, cdFalse) : otherwise?.unknownReferences ?? []);
     // we assign all with a maybe marker
     // we do not merge even if they appear in both branches because the maybe links will refer to different ids
-    const outgoing = [
-        ...cond.out,
-        ...(makeThenMaybe ? (0, environment_1.makeAllMaybe)(then?.out, nextGraph, finalEnvironment, true, cdTrue) : then?.out ?? []),
-        ...(makeOtherwiseMaybe ? (0, environment_1.makeAllMaybe)(otherwise?.out, nextGraph, finalEnvironment, true, cdFalse) : otherwise?.out ?? []),
-    ];
+    const outgoing = cond.out.concat((makeThenMaybe ? (0, environment_1.makeAllMaybe)(then?.out, nextGraph, finalEnvironment, true, cdTrue) : then?.out ?? []), (makeOtherwiseMaybe ? (0, environment_1.makeAllMaybe)(otherwise?.out, nextGraph, finalEnvironment, true, cdFalse) : otherwise?.out ?? []));
     (0, common_1.patchFunctionCall)({
         nextGraph,
         rootId,
@@ -98,10 +87,8 @@ function processIfThenElse(name, args, rootId, data) {
     });
     // as an if always evaluates its condition, we add a 'reads'-edge
     nextGraph.addEdge(name.info.id, cond.entryPoint, edge_1.EdgeType.Reads);
-    const exitPoints = [
-        ...(then?.exitPoints ?? []).map(e => ({ ...e, controlDependencies: makeThenMaybe ? [...data.controlDependencies ?? [], { id: rootId, when: true }] : e.controlDependencies })),
-        ...(otherwise?.exitPoints ?? []).map(e => ({ ...e, controlDependencies: makeOtherwiseMaybe ? [...data.controlDependencies ?? [], { id: rootId, when: false }] : e.controlDependencies }))
-    ];
+    const exitPoints = (then?.exitPoints ?? []).map(e => ({ ...e, controlDependencies: makeThenMaybe ? [...data.controlDependencies ?? [], { id: rootId, when: true }] : e.controlDependencies }))
+        .concat((otherwise?.exitPoints ?? []).map(e => ({ ...e, controlDependencies: makeOtherwiseMaybe ? [...data.controlDependencies ?? [], { id: rootId, when: false }] : e.controlDependencies })));
     return {
         unknownReferences: [],
         in: [{ nodeId: rootId, name: name.content, controlDependencies: originalDependency, type: identifier_1.ReferenceType.Function }, ...ingoing],

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

@@ -31,6 +31,7 @@ function processRepeatLoop(name, args, rootId, data) {
     const body = processedArguments[0];
     (0, assert_1.guard)(body !== undefined, () => `Repeat-Loop ${name.content} has no body, impossible!`);
     (0, linker_1.linkCircularRedefinitionsWithinALoop)(information.graph, (0, linker_1.produceNameSharedIdMap)((0, linker_1.findNonLocalReads)(information.graph, [])), body.out);
+    (0, linker_1.reapplyLoopExitPoints)(body.exitPoints, body.in.concat(body.out, body.unknownReferences));
     information.exitPoints = (0, info_1.filterOutLoopExitPoints)(information.exitPoints);
     return information;
 }

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

@@ -65,17 +65,16 @@ function processWhileLoop(name, args, rootId, data) {
         information.graph.addEdge(name.info.id, condition.entryPoint, edge_1.EdgeType.Reads);
         return condition;
     }
-    const remainingInputs = (0, linker_1.linkInputs)([
-        ...(0, environment_1.makeAllMaybe)(body.unknownReferences, information.graph, information.environment, false),
-        ...(0, environment_1.makeAllMaybe)(body.in, information.graph, information.environment, false)
-    ], information.environment, [...condition.in, ...condition.unknownReferences], information.graph, true);
+    const cdTrue = { id: name.info.id, when: true };
+    const remainingInputs = (0, linker_1.linkInputs)((0, environment_1.makeAllMaybe)(body.unknownReferences, information.graph, information.environment, false, cdTrue).concat((0, environment_1.makeAllMaybe)(body.in, information.graph, information.environment, false, cdTrue)), information.environment, condition.in.concat(condition.unknownReferences), information.graph, true);
     (0, linker_1.linkCircularRedefinitionsWithinALoop)(information.graph, (0, linker_1.produceNameSharedIdMap)((0, linker_1.findNonLocalReads)(information.graph, condition.in)), body.out);
+    (0, linker_1.reapplyLoopExitPoints)(body.exitPoints, body.in.concat(body.out, body.unknownReferences));
     // as the while-loop always evaluates its condition
     information.graph.addEdge(name.info.id, condition.entryPoint, edge_1.EdgeType.Reads);
     return {
         unknownReferences: [],
         in: [{ nodeId: name.info.id, name: name.lexeme, controlDependencies: originalDependency, type: identifier_1.ReferenceType.Function }, ...remainingInputs],
-        out: [...(0, environment_1.makeAllMaybe)(body.out, information.graph, information.environment, true), ...condition.out],
+        out: condition.out.concat((0, environment_1.makeAllMaybe)(body.out, information.graph, information.environment, true, cdTrue)),
         entryPoint: name.info.id,
         exitPoints: (0, info_1.filterOutLoopExitPoints)(body.exitPoints),
         graph: information.graph,

package/dataflow/internal/process/functions/call/common.js

@@ -29,11 +29,12 @@ function forceVertexArgumentValueReferences(rootId, value, graph, env) {
             }
         }
     }
-    const containedSubflowIn = [...graph.vertices(true)]
+    const containedSubflowIn = graph.vertices(true)
         .filter(([, info]) => (0, vertex_1.isFunctionDefinitionVertex)(info))
-        .flatMap(([, info]) => info);
+        .flatMap(([, info]) => info.subflow.in)
+        .toArray();
     // try to resolve them against the current environment
-    for (const ref of [...value.in, ...containedSubflowIn.flatMap(n => n.subflow.in)]) {
+    for (const ref of value.in.concat(containedSubflowIn)) {
         if (ref.name) {
             const resolved = ref.name ? (0, resolve_by_name_1.resolveByName)(ref.name, env, ref.type) ?? [] : [];
             for (const resolve of resolved) {

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

@@ -25,7 +25,11 @@ async function showQuery(shell, code, queries, { showCode, collapseResult, colla
         parser: shell,
         request: (0, retriever_1.requestFromInput)(code)
     }, config_1.defaultConfigOptions).allRemainingSteps();
-    const results = await Promise.resolve((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: (0, config_1.cloneConfig)(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.
@@ -48,7 +52,7 @@ ${collapseResult ? ' <details> <summary style="color:gray">Show Results</summary
 
 _Results (prettified and summarized):_
 
-${(0, query_print_1.asciiSummaryOfQueryResult)(ansi_1.markdownFormatter, duration, results, analysis)}
+${(0, query_print_1.asciiSummaryOfQueryResult)(ansi_1.markdownFormatter, duration, results, analysis, queries)}
 
 <details> <summary style="color:gray">Show Detailed Results as Json</summary>
 

package/documentation/doc-util/doc-types.d.ts

@@ -1,8 +1,9 @@
 import ts from 'typescript';
+export type TypeElementKind = 'interface' | 'type' | 'enum' | 'class' | 'variable';
 export interface TypeElementInSource {
     name: string;
     node: ts.Node;
-    kind: 'interface' | 'type' | 'enum' | 'class' | 'variable';
+    kind: TypeElementKind;
     extends: string[];
     generics: string[];
     filePath: string;
@@ -73,5 +74,9 @@ export declare function printCodeOfElement({ program, info }: FnInfo, name: stri
  */
 export declare function shortLink(name: string, hierarchy: readonly TypeElementInSource[], codeStyle?: boolean, realNameWrapper?: string): string;
 export declare function shortLinkFile(name: string, hierarchy: readonly TypeElementInSource[]): string;
-export declare function getDocumentationForType(name: string, hierarchy: TypeElementInSource[], prefix?: string, fuzzy?: boolean): string;
+export interface GetDocumentationForTypeFilters {
+    fuzzy?: boolean;
+    type?: TypeElementKind;
+}
+export declare function getDocumentationForType(name: string, hierarchy: TypeElementInSource[], prefix?: string, filter?: GetDocumentationForTypeFilters): string;
 export {};

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

@@ -32,7 +32,17 @@ const html_hover_over_1 = require("../../util/html-hover-over");
 const doc_general_1 = require("./doc-general");
 function getTypeScriptSourceFiles(fileNames) {
     try {
-        const program = typescript_1.default.createProgram(fileNames, { target: typescript_1.default.ScriptTarget.ESNext });
+        const program = typescript_1.default.createProgram(fileNames, {
+            target: typescript_1.default.ScriptTarget.ESNext,
+            skipLibCheck: true,
+            skipDefaultLibCheck: true,
+            allowJs: true,
+            checkJs: false,
+            strictNullChecks: false,
+            noUncheckedIndexedAccess: false,
+            noUncheckedSideEffectImports: false,
+            noCheck: true
+        });
         return { program, files: fileNames.map(fileName => program.getSourceFile(fileName)).filter(file => !!file) };
     }
     catch (err) {
@@ -391,7 +401,7 @@ function fuzzyCompare(a, b) {
     const bStr = b.toLowerCase().replace(/[^a-z0-9]/g, '-').trim();
     return aStr === bStr || aStr.includes(bStr) || bStr.includes(aStr);
 }
-function retrieveNode(name, hierarchy, fuzzy = false) {
+function retrieveNode(name, hierarchy, fuzzy = false, type = undefined) {
     let container = undefined;
     if (name.includes('::')) {
         [container, name] = name.split(/:::?/);
@@ -406,6 +416,12 @@ function retrieveNode(name, hierarchy, fuzzy = false) {
             return undefined;
         }
     }
+    if (type) {
+        node = node.filter(n => n.kind === type);
+        if (node.length === 0) {
+            return undefined;
+        }
+    }
     return [container, name, node[0]];
 }
 /**
@@ -440,8 +456,8 @@ function shortLinkFile(name, hierarchy) {
     const [, , node] = res;
     return `<a href="${getTypePathLink(node)}">${getTypePathForTypeScript(node)}</a>`;
 }
-function getDocumentationForType(name, hierarchy, prefix = '', fuzzy = false) {
-    const res = retrieveNode(name, hierarchy, fuzzy);
+function getDocumentationForType(name, hierarchy, prefix = '', filter) {
+    const res = retrieveNode(name, hierarchy, filter?.fuzzy, filter?.type);
     if (!res) {
         return '';
     }

package/documentation/print-core-wiki.js

@@ -50,6 +50,10 @@ async function getText(shell) {
         rootFolder: path_1.default.resolve('./src'),
         inlineTypes: doc_types_1.mermaidHide
     });
+    const testInfo = (0, doc_types_1.getTypesFromFolder)({
+        rootFolder: path_1.default.resolve('./test'),
+        inlineTypes: doc_types_1.mermaidHide
+    }).info;
     return `${(0, doc_auto_gen_1.autoGenHeader)({ filename: module.filename, purpose: 'core', rVersion: rversion })}
 
 This wiki page provides an overview of the inner workings of _flowR_.
@@ -390,7 +394,7 @@ ${await (0, doc_repl_1.documentReplSession)(shell, [{
 ### Getting flowR to Talk
 
 When using flowR from the CLI, you can use the ${(0, doc_cli_option_1.getCliLongOptionOf)('flowr', 'verbose')} option to get more information about what flowR is doing.
-While coding, however, you can use the ${(0, doc_types_1.shortLink)(log_1.setMinLevelOfAllLogs.name, info)} function to set the minimum level of logs to be displayed (this works with the ${(0, doc_types_1.shortLink)(log_2.FlowrLogger.name, info)} abstraction).
+While coding, however, you can use the ${(0, doc_types_1.shortLink)(log_1.setMinLevelOfAllLogs.name, testInfo)} function to set the minimum level of logs to be displayed (this works with the ${(0, doc_types_1.shortLink)(log_2.FlowrLogger.name, info)} abstraction).
 In general, you can configure the levels of individual logs, such as the general \`log\` (obtained with ${(0, doc_types_1.shortLink)('getActiveLog', info)}) or the ${(0, doc_types_1.shortLink)('parseLog', info)}.
 Please note that flowR makes no guarantees that log outputs are persistent across versions, and it is up to the implementors to provide sensible logging.
 If you are an implementor and want to add logging, please make sure there are no larger runtime impliciations when logging is disabled. 

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

@@ -74,7 +74,7 @@ async function explanation({ shell, name, type, description, code, expectedSubgr
 <a id='${name.toLowerCase().replaceAll(' ', '-')}'> </a>
 ### ${index}) ${name}
 
-Type: \`${type}\` (this is the numeric value of the bit-flag encountered when looking at the serialized vertex type)
+Type: \`${type}\` (this is the bit-flag value, e.g., when looking at the serialization)
 
 ${await subExplanation(shell, { name, description, code, expectedSubgraph })}
 
@@ -268,7 +268,7 @@ ${await (async () => {
                     const code = 'foo <- function() 3\nfoo()';
                     const [text, info] = await (0, doc_dfg_1.printDfGraphForCode)(shell, code, { exposeResult: true, mark: new Set([6, '6->0', '6->1', '6->3']) });
                     const numberOfEdges = [...info.dataflow.graph.edges()].flatMap(e => [...e[1].keys()]).length;
-                    const callVertex = [...info.dataflow.graph.vertices(true)].find(([, vertex]) => vertex.tag === vertex_1.VertexType.FunctionCall && vertex.name === 'foo');
+                    const callVertex = info.dataflow.graph.vertices(true).find(([, vertex]) => vertex.tag === vertex_1.VertexType.FunctionCall && vertex.name === 'foo');
                     (0, assert_1.guard)(callVertex !== undefined, () => `Could not find call vertex for ${code}`);
                     const [callId] = callVertex;
                     return `
@@ -367,11 +367,11 @@ ${(0, doc_structure_1.block)({
                 content: `Now you might be asking yourself how to differentiate anonymous and named functions and what you have to keep in mind when working with them?
 
 Unnamed functions have an array of signatures which you can use to identify them. 
-But in short - the \`origin\` attribute of the ${(0, doc_types_1.shortLink)('DataflowGraphVertexFunctionCall', vertexType.info)} is \`${unnamed_call_handling_1.UnnamedFunctionCallOrigin}\`.
+But in short: the \`origin\` attribute of the ${(0, doc_types_1.shortLink)('DataflowGraphVertexFunctionCall', vertexType.info)} is \`${unnamed_call_handling_1.UnnamedFunctionCallOrigin}\`.
 Please be aware that unnamed functions still have a \`name\` property to give it a unique identifier that can be used for debugging and reference.
 This name _always_ starts with \`${unnamed_call_handling_1.UnnamedFunctionCallPrefix}\`.
 
-To identify these calls please do not rely on the [Normalized AST](${doc_files_1.FlowrWikiBaseRef}/Normalized%20AST). An expression like \`1 + 1\` will be correctly
+To identify these calls please do not rely on the [normalized AST](${doc_files_1.FlowrWikiBaseRef}/Normalized-AST). An expression like \`1 + 1\` will be correctly
 identified as a syntactical binary operation. Yet, from a dataflow/semantic perspective this is equivalent to \`\` \`+\`(1, 1) \`\` (which is a named function call and marked as such in the dataflow graph).
 To know which function is called, please rely on the ${linkEdgeName(edge_1.EdgeType.Calls)} edge.
 	`
@@ -458,9 +458,10 @@ vertices of function definitions or not (e.g., \`${new graph_1.DataflowGraph(und
 
 ${(0, doc_structure_1.details)('Example: Nested Function Definitions', await (async () => {
                     const [text, info] = await (0, doc_dfg_1.printDfGraphForCode)(shell, 'f <- function() { g <- function() 3 }', { mark: new Set([9, 6]), exposeResult: true });
-                    const definitions = [...info.dataflow.graph.vertices(true)]
+                    const definitions = info.dataflow.graph.vertices(true)
                         .filter(([, vertex]) => vertex.tag === vertex_1.VertexType.FunctionDefinition)
-                        .map(([id, vertex]) => `| \`${id}\` | { \`${[...vertex.subflow.graph].join('`, `')}\` } |`);
+                        .map(([id, vertex]) => `| \`${id}\` | { \`${[...vertex.subflow.graph].join('`, `')}\` } |`)
+                        .toArray();
                     return `
 ${text}
 
@@ -766,6 +767,7 @@ async function getText(shell) {
 
 This page briefly summarizes flowR's dataflow graph, represented by the ${(0, doc_types_1.shortLink)(graph_1.DataflowGraph.name, vertexType.info)} class within the code.
 In case you want to manually build such a graph (e.g., for testing), you can use the ${(0, doc_types_1.shortLink)(dataflowgraph_builder_1.DataflowGraphBuilder.name, vertexType.info)}.
+If you are interested in which features we support and which features are still to be worked on, please refer to our [capabilities](${doc_files_1.FlowrWikiBaseRef}/Capabilities) page.
 In summary, we discuss the following topics:
 
 - [Vertices](#vertices)
@@ -777,7 +779,7 @@ In summary, we discuss the following topics:
 
 Please be aware that the accompanied [dataflow information](#dataflow-information) (${(0, doc_types_1.shortLink)('DataflowInformation', vertexType.info)}) returned by _flowR_ contains things besides the graph,
 like the entry and exit points of the subgraphs, and currently active references (see [below](#dataflow-information)).
-Additionally, you may be interested in the set of [Unknown Side Effects](#unknown-side-effects) marking calls which _flowR_ is unable to handle correctly.
+Additionally, you may be interested in the set of [Unknown Side Effects](#unknown-side-effects), marking calls which _flowR_ is unable to handle correctly.
 
 Potentially, you are interested in another perspective that flowR provides, the [control flow graph](${doc_files_1.FlowrWikiBaseRef}/Control%20Flow%20Graph), so please check the correpsonding
 wiki page if you are unsure.
@@ -829,16 +831,16 @@ From an implementation perspective all of these types are represented by respect
 The following sections present details on the different types of vertices and edges, including examples and explanations.
 
 > [!NOTE]
-> Every dataflow vertex holds an \`id\` which links it to the respective node in the [normalized AST](${doc_files_1.FlowrWikiBaseRef}/Normalized%20AST).
+> Every dataflow vertex holds an \`id\` which links it to the respective node in the [normalized AST](${doc_files_1.FlowrWikiBaseRef}/Normalized-AST).
 > So if you want more information about the respective vertex, you can usually access more information
 > using the <code>${(0, doc_types_1.shortLink)(`${graph_1.DataflowGraph.name}`, vertexType.info, false, 'i')}::idMap</code> linked to the dataflow graph:
 ${(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.
+> Please note, that not every node in the [normalized AST](${doc_files_1.FlowrWikiBaseRef}/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
+> is configured to ignore dead code (there are more powerful dead code capabilities with the [CFG](${doc_files_1.FlowrWikiBaseRef}/Control-Flow-Graph)). 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.
@@ -990,7 +992,8 @@ Depending on what you are interested in, there exists a plethora of functions an
 * ${(0, doc_types_1.shortLink)(identify_link_to_last_call_relation_1.getValueOfArgument.name, vertexType.info)} to get the (syntactical) value of an argument in a function call 
 * ${(0, doc_types_1.shortLink)(dfg_get_origin_1.getOriginInDfg.name, vertexType.info)} to get information about where a read, call, ... comes from (see [below](#dfg-resolving-values))
 
-Some of these functions have been explained in their respective wiki pages. However, some are part of the [Dataflow Graph API](${doc_files_1.FlowrWikiBaseRef}/Dataflow%20Graph%20API) and so we explain them here.
+Some of these functions have been explained in their respective wiki pages. However, some are part of the [Dataflow Graph API](${doc_files_1.FlowrWikiBaseRef}/Dataflow-Graph) and so we explain them here.
+If you are interested in which features we support and which features are still to be worked on, please refer to our [capabilities](${doc_files_1.FlowrWikiBaseRef}/Capabilities) page.
 
 ${(0, doc_structure_1.section)('Resolving Values', 3, 'dfg-resolving-values')}
 
@@ -999,6 +1002,12 @@ These capabilities are exposed by the [resolve value Query](${doc_files_1.FlowrW
 
 ${(0, doc_types_1.shortLink)(alias_tracking_1.resolveIdToValue.name, vertexType.info)} provides an environment-sensitive (see ${(0, doc_types_1.shortLink)('REnvironmentInformation', vertexType.info)})
 value resolution depending on if the environment is provided.
+The idea of ${(0, doc_types_1.shortLink)(alias_tracking_1.resolveIdToValue.name, vertexType.info)} is to provide a compromise between precision and performance, to
+be used _during_ and _after_ the core analysis. After the dataflow analysis completes, there are much more expensive queries possible (such as the resolution of the data frame shape, see the [Query API](${doc_files_1.FlowrWikiBaseRef}/Query-API)).
+
+Additionally, to ${(0, doc_types_1.shortLink)(alias_tracking_1.resolveIdToValue.name, vertexType.info)}, we offer the aforementioned ${(0, doc_types_1.shortLink)(identify_link_to_last_call_relation_1.getValueOfArgument.name, vertexType.info)} to retrieve the value of an argument in a function call.
+Be aware, that this function is currently not optimized for speed, so if you frequently require the values of multiple arguments of the same function call, you may want to open [an issue](${doc_issue_1.NewIssueUrl}) to request support for resolving
+multiple arguments at once.
 
 ${(0, doc_structure_1.section)('Assessing Edges', 3, 'dfg-assess-edge')}
 
@@ -1035,7 +1044,7 @@ ${(0, doc_types_1.printHierarchy)({ program: vertexType.program, info: vertexTyp
 
 Their respective uses are documented alongside their implementation:
 
-${['SimpleOrigin', 'FunctionCallOrigin', 'BuiltInFunctionOrigin'].sort().map(key => `- ${(0, doc_types_1.shortLink)(`${key}`, vertexType.info)}\\\n${(0, doc_types_1.getDocumentationForType)(`${key}`, vertexType.info)}`).join('\n')}
+${['SimpleOrigin', 'FunctionCallOrigin', 'BuiltInFunctionOrigin'].sort().map(key => `- ${(0, doc_types_1.shortLink)(key, vertexType.info)}\\\n${(0, doc_types_1.getDocumentationForType)(key, vertexType.info, '', { type: 'interface' })}`).join('\n')}
 
 Please note, the current structure of this function is biased by what implementations already exist in flowR.
 Hence, we do not just track definitions and constants, but also the origins of function calls, albeit we do not yet track the origins of values (only resorting to

package/documentation/print-faq-wiki.js

@@ -15,6 +15,11 @@ ${qAndA('What are test labels and how do they work?', `
 Tests are labeled based on the *flowR* capabilities that they test for. The list of supported capabilities can be found on the [Capabilities](${doc_files_1.FlowrWikiBaseRef}/Capabilities) wiki page. For more extensive information on test labels, see the [test labels wiki section](${doc_files_1.FlowrWikiBaseRef}/Linting-and-Testing#test-labels).
 `)}
 
+${qAndA('How to get a REPL with debug-info/hot-reload?', `
+To enter the development repl, execute \`npm run main-dev\` in contrast to \`npm run flowr\` this will use an unminified build (keeping debug info)
+and will also watch the source files for changes and automatically recompile them. Please note, that this may have negative performance implications.
+`)}
+
 ${qAndA('How do I generate mermaid diagrams?', `
 There are several ways to generate mermaid diagrams based on the input data that you want to use.
 - From the AST (abstract syntax tree): ${(0, doc_files_1.getFilePathMd)('../util/mermaid/ast.ts')}

package/documentation/print-interface-wiki.js

@@ -116,6 +116,8 @@ which is interpreted as an R expression by default but interpreted as a *co
 The best command to get started with the REPL is ${(0, doc_cli_option_1.getReplCommand)('help')}.
 Besides, you can leave the REPL either with the command ${(0, doc_cli_option_1.getReplCommand)('quit')} or by pressing <kbd>CTRL</kbd>+<kbd>C</kbd> twice.
 
+> [!NOTE]
+> If you develop flowR, you may want to launch the repl using the \`npm run main-dev\` command, this way, you get a non-minified version of flowR with debug information and hot-reloading of source files.
 
 <details>
 <summary>Available Commands</summary>

package/documentation/print-linter-wiki.js

@@ -28,7 +28,7 @@ const SpecialTagColors = {
     [linter_tags_1.LintingRuleTag.QuickFix]: 'lightgray'
 };
 function makeTagBadge(name, info) {
-    const doc = (0, doc_types_1.getDocumentationForType)('LintingRuleTag::' + name, info, '', true).replaceAll('\n', ' ');
+    const doc = (0, doc_types_1.getDocumentationForType)('LintingRuleTag::' + name, info, '', { fuzzy: true }).replaceAll('\n', ' ');
     return (0, html_hover_over_1.textWithTooltip)(`<a href='#${name}'>![` + name + '](https://img.shields.io/badge/' + name.toLowerCase() + `-${SpecialTagColors[name] ?? 'teal'}) </a>`, doc);
 }
 function prettyPrintExpectedOutput(expected) {
@@ -66,7 +66,6 @@ These examples are synthesized from the test cases in: ${(0, doc_files_1.linkFlo
         }
         const testName = args[0].getText(report.source);
         if (report.comments?.some(c => c.includes('@ignore-in-wiki'))) {
-            console.warn(`Skipping test case for linter rule ${testName} (${testFile}) as it is marked with @ignore-in-wiki`);
             continue;
         }
         // drop any quotes around the test name
@@ -133,7 +132,7 @@ df[6, "value"]
             }
             return a.localeCompare(b);
         }).map(t => makeTagBadge(t, types)).join(' ');
-        const certaintyDoc = (0, doc_types_1.getDocumentationForType)(`LintingRuleCertainty::${rule.info.certainty}`, types, '', true).replaceAll('\n', ' ');
+        const certaintyDoc = (0, doc_types_1.getDocumentationForType)(`LintingRuleCertainty::${rule.info.certainty}`, types, '', { fuzzy: true }).replaceAll('\n', ' ');
         const certaintyText = `\`${(0, html_hover_over_1.textWithTooltip)(rule.info.certainty, certaintyDoc)}\``;
         if (format === 'short') {
             ruleExplanations.set(name, () => Promise.resolve(`

package/documentation/print-linting-and-testing-wiki.js

@@ -201,6 +201,10 @@ To get started, install the [vitest Extension](https://marketplace.visualstudio.
 #### Webstorm
 
 Please follow the official guide [here](https://www.jetbrains.com/help/webstorm/vitest.html).
+Note that the working directory has to be set to the project root directory, not the test subdirectory!
+Otherwise, the tests will not be instantiated.
+
+![Webstorm test configuration](img/testing-webstorm.png)
 
 <a id='ci-pipeline'></a>
 ## 🪈 CI Pipeline