@eagleoutice/flowr 2.2.15 → 2.3.0

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

@@ -1,5 +1,6 @@
 import { type DataflowProcessorInformation } from '../../../../../processor';
 import type { DataflowInformation } from '../../../../../info';
+import type { FlowrLaxSourcingOptions } from '../../../../../../config';
 import { InferWorkingDirectory } from '../../../../../../config';
 import type { RParseRequest, RParseRequestProvider } from '../../../../../../r-bridge/retriever';
 import type { IdGenerator, ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
@@ -7,14 +8,16 @@ 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[];
 /**
  * Tries to find sourced by a source request and returns the first path that exists
- * @param seed - the path originally requested in the `source` call
- * @param data - more information on the loading context
+ * @param resolveSource - options for lax file sourcing
+ * @param seed          - the path originally requested in the `source` call
+ * @param data          - more information on the loading context
  */
-export declare function findSource(seed: string, data: {
+export declare function findSource(resolveSource: FlowrLaxSourcingOptions | undefined, seed: string, data: {
     referenceChain: readonly RParseRequest[];
 }): string[] | undefined;
 export declare function processSourceCall<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {

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;
 }
@@ -68,18 +72,18 @@ function applyReplacements(path, replacements) {
 }
 /**
  * Tries to find sourced by a source request and returns the first path that exists
- * @param seed - the path originally requested in the `source` call
- * @param data - more information on the loading context
+ * @param resolveSource - options for lax file sourcing
+ * @param seed          - the path originally requested in the `source` call
+ * @param data          - more information on the loading context
  */
-function findSource(seed, data) {
-    const config = (0, config_1.getConfig)().solver.resolveSource;
-    const capitalization = config?.ignoreCapitalization ?? false;
+function findSource(resolveSource, seed, data) {
+    const capitalization = resolveSource?.ignoreCapitalization ?? false;
     const explorePaths = [
-        ...(config?.searchPath ?? []),
-        ...(inferWdFromScript(config?.inferWorkingDirectory ?? config_1.InferWorkingDirectory.No, data.referenceChain))
+        ...(resolveSource?.searchPath ?? []),
+        ...(inferWdFromScript(resolveSource?.inferWorkingDirectory ?? config_1.InferWorkingDirectory.No, data.referenceChain))
     ];
     let tryPaths = [seed];
-    switch (config?.dropPaths ?? config_1.DropPathsOption.No) {
+    switch (resolveSource?.dropPaths ?? config_1.DropPathsOption.No) {
         case config_1.DropPathsOption.Once: {
             const first = platformBasename(seed);
             tryPaths.push(first);
@@ -101,8 +105,8 @@ function findSource(seed, data) {
         case config_1.DropPathsOption.No:
             break;
     }
-    if (config?.applyReplacements) {
-        const r = config.applyReplacements;
+    if (resolveSource?.applyReplacements) {
+        const r = resolveSource.applyReplacements;
         tryPaths = tryPaths.flatMap(t => applyReplacements(t, r));
     }
     const found = [];
@@ -129,7 +133,7 @@ function processSourceCall(name, args, rootId, data, config) {
         (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'builtin:source' }).information
         : (0, info_1.initializeCleanDataflowInformation)(rootId, data);
     const sourceFileArgument = args[0];
-    if (!config.forceFollow && (0, config_1.getConfig)().ignoreSourceCalls) {
+    if (!config.forceFollow && data.flowrConfig.ignoreSourceCalls) {
         (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Skipping source call ${JSON.stringify(sourceFileArgument)} (disabled in config file)`);
         (0, unknown_side_effect_1.handleUnknownSideEffect)(information.graph, information.environment, rootId);
         return information;
@@ -139,19 +143,19 @@ function processSourceCall(name, args, rootId, data, config) {
         sourceFile = [(0, retriever_1.removeRQuotes)(sourceFileArgument.lexeme)];
     }
     else if (sourceFileArgument !== r_function_call_1.EmptyArgument) {
-        const resolved = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(sourceFileArgument.info.id, { environment: data.environment, idMap: data.completeAst.idMap }));
+        const resolved = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(sourceFileArgument.info.id, { environment: data.environment, idMap: data.completeAst.idMap, resolve: data.flowrConfig.solver.variables }));
         sourceFile = resolved?.elements.map(r => r.type === 'string' && (0, r_value_1.isValue)(r.value) ? r.value.str : undefined).filter(assert_1.isNotUndefined);
     }
     if (sourceFile && sourceFile.length === 1) {
         const path = (0, retriever_1.removeRQuotes)(sourceFile[0]);
-        let filepath = path ? findSource(path, data) : path;
+        let filepath = path ? findSource(data.flowrConfig.solver.resolveSource, path, data) : path;
         if (Array.isArray(filepath)) {
             filepath = filepath?.[0];
         }
         if (filepath !== undefined) {
             const request = sourceProvider.createRequest(filepath);
             // check if the sourced file has already been dataflow analyzed, and if so, skip it
-            const limit = (0, config_1.getConfig)().solver.resolveSource?.repeatedSourceLimit ?? 0;
+            const limit = data.flowrConfig.solver.resolveSource?.repeatedSourceLimit ?? 0;
             const findCount = data.referenceChain.filter(e => e.request === request.request && e.content === request.content).length;
             if (findCount > limit) {
                 logger_1.dataflowLogger.warn(`Found cycle (>=${limit + 1}) in dataflow analysis for ${JSON.stringify(request)}: ${JSON.stringify(data.referenceChain)}, skipping further dataflow analysis`);
@@ -181,7 +185,7 @@ function sourceRequest(rootId, request, data, information, getId) {
         const file = request.request === 'file' ? request.content : undefined;
         const parsed = (!data.parser.async ? data.parser : new shell_executor_1.RShellExecutor()).parse(request);
         normalized = (typeof parsed !== 'string' ?
-            (0, parser_1.normalizeTreeSitter)({ parsed }, getId, file) : (0, parser_1.normalize)({ parsed }, getId, file));
+            (0, parser_1.normalizeTreeSitter)({ parsed }, getId, data.flowrConfig, file) : (0, parser_1.normalize)({ parsed }, getId, file));
         dataflow = (0, processor_1.processDataflowFor)(normalized.ast, {
             ...data,
             currentRequest: request,

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

@@ -16,7 +16,7 @@ const containers_1 = require("../../../../../../util/containers");
  */
 function processVector(name, args, rootId, data) {
     const fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'builtin:vector' });
-    if (!(0, config_1.getConfig)().solver.pointerTracking) {
+    if (!data.flowrConfig.solver.pointerTracking) {
         return fnCall.information;
     }
     let vectorArgs = [];
@@ -52,7 +52,7 @@ function processVector(name, args, rootId, data) {
             vectorArgs = vectorArgs.concat(flattenedIndices);
         }
     }
-    if ((0, config_1.isOverPointerAnalysisThreshold)(vectorArgs.length)) {
+    if ((0, config_1.isOverPointerAnalysisThreshold)(data.flowrConfig, vectorArgs.length)) {
         return fnCall.information;
     }
     const indices = {

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

@@ -24,7 +24,7 @@ function processWhileLoop(name, args, rootId, data) {
         return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'default' }).information;
     }
     // we should defer this to the abstract interpretation
-    const values = (0, alias_tracking_1.resolveIdToValue)(unpackedArgs[0]?.info.id, { environment: data.environment, idMap: data.completeAst.idMap });
+    const values = (0, alias_tracking_1.resolveIdToValue)(unpackedArgs[0]?.info.id, { environment: data.environment, idMap: data.completeAst.idMap, resolve: data.flowrConfig.solver.variables });
     const conditionIsAlwaysFalse = (0, general_1.valueSetGuard)(values)?.elements.every(d => d.type === 'logical' && d.value === false) ?? false;
     //We don't care about the body if it never executes
     if (conditionIsAlwaysFalse) {

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

@@ -83,7 +83,7 @@ function processAllArguments({ functionName, args, data, finalGraph, functionRoo
                     // When only a single index is referenced, we don't need to reference the whole object
                     const resolvedInGraphDef = resolved;
                     const isContainer = checkForContainer(resolvedInGraphDef?.indicesCollection);
-                    if (isContainer || isContainer === undefined) {
+                    if (isContainer !== false) {
                         finalGraph.addEdge(ingoing.nodeId, resolved.nodeId, edge_1.EdgeType.Reads);
                     }
                 }

package/dataflow/internal/process/functions/process-parameter.js

@@ -20,7 +20,7 @@ function processFunctionParameter(parameter, data) {
     for (const writtenNode of writtenNodes) {
         log_1.log.trace(`parameter ${writtenNode.name} (${writtenNode.nodeId}) is defined at id ${writtenNode.definedAt} with ${defaultValue === undefined ? 'no default value' : ' no default value'}`);
         graph.setDefinitionOfVertex(writtenNode);
-        environment = (0, define_1.define)(writtenNode, false, environment);
+        environment = (0, define_1.define)(writtenNode, false, environment, data.flowrConfig);
         if (defaultValue !== undefined) {
             if (parameter.defaultValue?.type === type_1.RType.FunctionDefinition) {
                 graph.addEdge(writtenNode, parameter.defaultValue.info.id, edge_1.EdgeType.DefinedBy);

package/dataflow/origin/dfg-get-symbol-refs.d.ts

@@ -0,0 +1,21 @@
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { DataflowGraph } from '../graph/graph';
+/**
+ * Finds the definition of a variable and all other uses from that point on
+ *
+ * For example, for the following code
+ * ```ts
+ *   y <- 5
+ *   f <- function() {
+ *     y <- 8
+ *     print(y)
+ *   }
+ * ```
+ *
+ * @example getAllRefsToSymbol('3\@y') returns ['3\@y', '4\@y']
+ *
+ * @param graph  - Dataflow Graph
+ * @param nodeId - NodeId of Symbol to resolve
+ * @returns List including the Definitions and Refereneces to that definition
+ */
+export declare function getAllRefsToSymbol(graph: DataflowGraph, nodeId: NodeId): NodeId[] | undefined;

package/dataflow/origin/dfg-get-symbol-refs.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllRefsToSymbol = getAllRefsToSymbol;
+const edge_1 = require("../graph/edge");
+const info_1 = require("../info");
+const dfg_get_origin_1 = require("./dfg-get-origin");
+/**
+ * Finds the definition of a variable and all other uses from that point on
+ *
+ * For example, for the following code
+ * ```ts
+ *   y <- 5
+ *   f <- function() {
+ *     y <- 8
+ *     print(y)
+ *   }
+ * ```
+ *
+ * @example getAllRefsToSymbol('3\@y') returns ['3\@y', '4\@y']
+ *
+ * @param graph  - Dataflow Graph
+ * @param nodeId - NodeId of Symbol to resolve
+ * @returns List including the Definitions and Refereneces to that definition
+ */
+function getAllRefsToSymbol(graph, nodeId) {
+    // Get all origins and filter for ones that happen for sure
+    const origins = (0, dfg_get_origin_1.getOriginInDfg)(graph, nodeId);
+    if (origins === undefined) {
+        return undefined;
+    }
+    const definitiveOrigins = origins.filter(o => (0, info_1.happensInEveryBranch)(graph.getVertex(o.id)?.cds));
+    if (definitiveOrigins.length === 0) {
+        return undefined;
+    }
+    // Gather all the references 
+    const res = new Set();
+    for (const origin of definitiveOrigins) {
+        res.add(origin.id);
+        graph.ingoingEdges(origin.id)
+            ?.entries()
+            .filter(([_, edge]) => (0, edge_1.edgeIncludesType)(edge.types, edge_1.EdgeType.Reads))
+            .forEach(([node, _]) => res.add(node));
+        graph.outgoingEdges(origin.id)
+            ?.entries()
+            .filter(([_, edge]) => (0, edge_1.edgeIncludesType)(edge.types, edge_1.EdgeType.DefinedByOnCall))
+            .forEach(([node, _]) => res.add(node));
+    }
+    return [...res];
+}
+//# sourceMappingURL=dfg-get-symbol-refs.js.map

package/dataflow/processor.d.ts

@@ -7,6 +7,7 @@ import type { REnvironmentInformation } from './environments/environment';
 import type { RParseRequest } from '../r-bridge/retriever';
 import type { RNode } from '../r-bridge/lang-4.x/ast/model/model';
 import type { KnownParserType, Parser } from '../r-bridge/parser';
+import type { FlowrConfigOptions } from '../config';
 export interface DataflowProcessorInformation<OtherInfo> {
     readonly parser: Parser<KnownParserType>;
     /**
@@ -35,6 +36,10 @@ export interface DataflowProcessorInformation<OtherInfo> {
      * The chain of control-flow {@link NodeId}s that lead to the current node (e.g., of known ifs).
      */
     readonly controlDependencies: ControlDependency[] | undefined;
+    /**
+     * The flowr configuration used for environment seeding, and precision control
+     */
+    readonly flowrConfig: FlowrConfigOptions;
 }
 export type DataflowProcessor<OtherInfo, NodeType extends RNodeWithParent<OtherInfo>> = (node: NodeType, data: DataflowProcessorInformation<OtherInfo>) => DataflowInformation;
 type NodeWithKey<OtherInfo, Key> = RNode<OtherInfo & ParentInformation> & {

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

@@ -11,13 +11,14 @@ const doc_files_1 = require("./doc-files");
 const cfg_1 = require("../../util/mermaid/cfg");
 const doc_code_1 = require("./doc-code");
 const cfg_simplification_1 = require("../../control-flow/cfg-simplification");
+const config_1 = require("../../config");
 async function getCfg(parser, code, simplifications = [], useDfg = true) {
     const result = useDfg ? await (0, default_pipelines_1.createDataflowPipeline)(parser, {
         request: (0, retriever_1.requestFromInput)(code)
-    }).allRemainingSteps() : await (0, default_pipelines_1.createNormalizePipeline)(parser, {
+    }, config_1.defaultConfigOptions).allRemainingSteps() : await (0, default_pipelines_1.createNormalizePipeline)(parser, {
         request: (0, retriever_1.requestFromInput)(code)
-    }).allRemainingSteps();
-    const cfg = (0, extract_cfg_1.extractCfg)(result.normalize, useDfg ? result.dataflow.graph : undefined, [...cfg_simplification_1.DefaultCfgSimplificationOrder, ...simplifications]);
+    }, config_1.defaultConfigOptions).allRemainingSteps();
+    const cfg = (0, extract_cfg_1.extractCfg)(result.normalize, config_1.defaultConfigOptions, useDfg ? result.dataflow.graph : undefined, [...cfg_simplification_1.DefaultCfgSimplificationOrder, ...simplifications]);
     return {
         info: cfg,
         ast: result.normalize,

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

@@ -1,3 +1,3 @@
-export declare function codeBlock(language: string, code: string | undefined): string;
+export declare function codeBlock(language: string, code: string): string;
 export declare function codeInline(code: string): string;
 export declare function jsonWithLimit(object: object, maxLength?: number, tooLongText?: string): string;

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

@@ -15,6 +15,7 @@ const assert_1 = require("../../util/assert");
 const time_1 = require("../../util/text/time");
 const doc_files_1 = require("./doc-files");
 const doc_code_1 = require("./doc-code");
+const config_1 = require("../../config");
 function printDfGraph(graph, mark, simplified = false) {
     return `
 ${(0, doc_code_1.codeBlock)('mermaid', (0, dfg_1.graphToMermaid)({
@@ -37,7 +38,7 @@ async function printDfGraphForCode(parser, code, { simplified = false, mark, sho
     const now = performance.now();
     const result = await (0, default_pipelines_1.createDataflowPipeline)(parser, {
         request: (0, retriever_1.requestFromInput)(code)
-    }).allRemainingSteps();
+    }, config_1.defaultConfigOptions).allRemainingSteps();
     const duration = performance.now() - now;
     if (switchCodeAndGraph) {
         (0, assert_1.guard)(showCode, 'can not switch code and graph if code is not shown');
@@ -76,7 +77,7 @@ async function verifyExpectedSubgraph(shell, code, expectedSubgraph) {
         parser: shell,
         request: (0, retriever_1.requestFromInput)(code),
         getId: (0, decorate_1.deterministicCountingIdGenerator)(0)
-    }).allRemainingSteps();
+    }, config_1.defaultConfigOptions).allRemainingSteps();
     expectedSubgraph.setIdMap(info.normalize.idMap);
     expectedSubgraph = (0, resolve_graph_1.resolveDataflowGraph)(expectedSubgraph);
     const report = (0, diff_dataflow_graph_1.diffOfDataflowGraphs)({ name: 'expected', graph: expectedSubgraph }, { name: 'got', graph: info.dataflow.graph }, {

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

@@ -0,0 +1,24 @@
+import type { Expression } from 'typescript';
+import ts from 'typescript';
+export interface FunctionElementInSource {
+    name: string;
+    node: ts.Node;
+    source: ts.SourceFile;
+    kind: 'function';
+    arguments: Expression[];
+    lineNumber: number;
+    comments?: string[];
+}
+export interface GetFunctionsOption {
+    readonly rootFolder?: string;
+    readonly files?: readonly string[];
+    readonly fname?: RegExp;
+}
+export interface FunctionsReport {
+    info: FunctionElementInSource[];
+    program: ts.Program;
+}
+/**
+ * Inspect typescript source code for types and return a report.
+ */
+export declare function getFunctionsFromFolder(options: GetFunctionsOption): FunctionsReport;

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

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFunctionsFromFolder = getFunctionsFromFolder;
+const typescript_1 = __importDefault(require("typescript"));
+const assert_1 = require("../../util/assert");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const doc_types_1 = require("./doc-types");
+function collectHierarchyInformation(sourceFiles, options, fname) {
+    const hierarchyList = [];
+    const visit = (node, sourceFile) => {
+        if (!node) {
+            return;
+        }
+        if (typescript_1.default.isCallExpression(node) || typescript_1.default.isNewExpression(node)) {
+            const name = node.expression.getText(sourceFile);
+            if (!fname || fname.test(name)) {
+                const comments = typescript_1.default.getLeadingCommentRanges(sourceFile.getText(sourceFile), node.getFullStart())?.map(c => {
+                    return (0, doc_types_1.removeCommentSymbolsFromTypeScriptComment)(sourceFile.getText(sourceFile).substring(c.pos, c.end).trim());
+                });
+                hierarchyList.push({
+                    name: (0, doc_types_1.dropGenericsFromTypeName)(name),
+                    node,
+                    kind: 'function',
+                    comments,
+                    lineNumber: (0, doc_types_1.getStartLineOfTypeScriptNode)(node, sourceFile),
+                    source: sourceFile,
+                    arguments: node.arguments?.map(n => n) ?? []
+                });
+            }
+        }
+        typescript_1.default.forEachChild(node, child => visit(child, sourceFile));
+    };
+    sourceFiles.forEach(sourceFile => {
+        visit(sourceFile, sourceFile);
+    });
+    return hierarchyList;
+}
+/**
+ * Inspect typescript source code for types and return a report.
+ */
+function getFunctionsFromFolder(options) {
+    (0, assert_1.guard)(options.rootFolder !== undefined || options.files !== undefined, 'Either rootFolder or files must be provided');
+    const fileNames = [...options.files ?? []];
+    if (options.rootFolder) {
+        for (const fileBuff of fs_1.default.readdirSync(options.rootFolder, { recursive: true })) {
+            const file = fileBuff.toString();
+            if (file.endsWith('.ts')) {
+                fileNames.push(path_1.default.join(options.rootFolder, file));
+            }
+        }
+    }
+    const { files, program } = (0, doc_types_1.getTypeScriptSourceFiles)(fileNames);
+    (0, assert_1.guard)(files.length > 0, () => `No source files found for ${JSON.stringify(fileNames)}`);
+    const withProgram = { ...options, program };
+    const hierarchyList = collectHierarchyInformation(files, withProgram, options.fname);
+    return {
+        info: hierarchyList,
+        program
+    };
+}
+//# sourceMappingURL=doc-functions.js.map

package/documentation/doc-util/doc-normalized-ast.js

@@ -12,6 +12,7 @@ const assert_1 = require("../../util/assert");
 const ast_1 = require("../../util/mermaid/ast");
 const time_1 = require("../../util/text/time");
 const doc_files_1 = require("./doc-files");
+const config_1 = require("../../config");
 function printNormalizedAst(ast, prefix = 'flowchart TD\n') {
     return `
 \`\`\`mermaid
@@ -23,7 +24,7 @@ async function printNormalizedAstForCode(parser, code, { showCode = true, prefix
     const now = performance.now();
     const result = await (0, default_pipelines_1.createNormalizePipeline)(parser, {
         request: (0, retriever_1.requestFromInput)(code)
-    }).allRemainingSteps();
+    }, config_1.defaultConfigOptions).allRemainingSteps();
     const duration = performance.now() - now;
     const metaInfo = `The analysis required _${(0, time_1.printAsMs)(duration)}_ (including parsing with the [${parser.name}](${doc_files_1.FlowrWikiBaseRef}/Engines) engine) within the generation environment.`;
     return '\n\n' + printNormalizedAst(result.normalize.ast, prefix) + (showCode ? `
@@ -57,7 +58,7 @@ async function verifyExpectedSubgraph(shell, code, expectedSubgraph) {
     const info = await (0, default_pipelines_1.createDataflowPipeline)(shell, {
         request: (0, retriever_1.requestFromInput)(code),
         getId: (0, decorate_1.deterministicCountingIdGenerator)(0)
-    }).allRemainingSteps();
+    }, config_1.defaultConfigOptions).allRemainingSteps();
     expectedSubgraph.setIdMap(info.normalize.idMap);
     expectedSubgraph = (0, resolve_graph_1.resolveDataflowGraph)(expectedSubgraph);
     const report = (0, diff_dataflow_graph_1.diffOfDataflowGraphs)({ name: 'expected', graph: expectedSubgraph }, { name: 'got', graph: info.dataflow.graph }, {

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

@@ -0,0 +1,5 @@
+/**
+ * Writes the wiki documentation to the specified output path.
+ * Returns true if the file was updated, false if it was unchanged.
+ */
+export declare function writeWikiTo(text: string, output_path: string, check_change?: boolean): boolean;

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

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeWikiTo = writeWikiTo;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/* eslint-disable */
+const IgnoreRegex = /[0-9]+(\.[0-9]+)? ?ms|"timing":\s*[0-9]+(\.0-9)?,?|tmp-[A-Za-z0-9-]+/g;
+/* eslint-enable */
+/**
+ * Checks whether the file contains a different content, but ignores timing and some other non-semantic changes.
+ */
+function didFileChange(filePath, content) {
+    if (!fs_1.default.existsSync(filePath)) {
+        return true; // If the file does not exist, it is considered changed.
+    }
+    const currentContent = fs_1.default.readFileSync(filePath, 'utf-8');
+    const cleanedCurrentContent = currentContent.replace(IgnoreRegex, '');
+    const cleanedNewContent = content.replace(IgnoreRegex, '');
+    return cleanedCurrentContent !== cleanedNewContent;
+}
+/**
+ * Writes the wiki documentation to the specified output path.
+ * Returns true if the file was updated, false if it was unchanged.
+ */
+function writeWikiTo(text, output_path, check_change = true) {
+    if (!check_change || didFileChange(output_path, text)) {
+        fs_1.default.mkdirSync(path_1.default.dirname(output_path), { recursive: true });
+        fs_1.default.writeFileSync(output_path, text, 'utf-8');
+        return true;
+    }
+    return false;
+}
+//# sourceMappingURL=doc-print.js.map

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

@@ -17,13 +17,15 @@ 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();
     const analysis = await new pipeline_executor_1.PipelineExecutor(default_pipelines_1.DEFAULT_DATAFLOW_PIPELINE, {
         parser: shell,
         request: (0, retriever_1.requestFromInput)(code)
-    }).allRemainingSteps();
-    const results = (0, query_1.executeQueries)({ dataflow: analysis.dataflow, ast: analysis.normalize }, queries);
+    }, config_1.defaultConfigOptions).allRemainingSteps();
+    const results = (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.
@@ -33,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-repl.js

@@ -11,6 +11,7 @@ const doc_docker_1 = require("./doc-docker");
 const prompt_1 = require("../../cli/repl/prompt");
 const doc_code_1 = require("./doc-code");
 const print_version_1 = require("../../cli/repl/print-version");
+const config_1 = require("../../config");
 function printHelpForScript(script, starredVersion) {
     let base = `| **${(0, doc_cli_option_1.getReplCommand)(script[0], false, starredVersion !== undefined)}** | ${script[1].description}`;
     if (starredVersion) {
@@ -51,7 +52,7 @@ async function documentReplSession(parser, commands, options) {
                 entry.lines.push(msg);
             }
         };
-        await (0, core_1.replProcessAnswer)(collectingOutput, command.command, parser, options?.allowRSessionAccess ?? false);
+        await (0, core_1.replProcessAnswer)(config_1.defaultConfigOptions, collectingOutput, command.command, parser, options?.allowRSessionAccess ?? false);
         collect.push(entry);
     }
     let result = '';

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

@@ -17,13 +17,14 @@ const flowr_search_executor_1 = require("../../search/flowr-search-executor");
 const flowr_search_printer_1 = require("../../search/flowr-search-printer");
 const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
 const dfg_1 = require("../../util/mermaid/dfg");
+const config_1 = require("../../config");
 async function showSearch(shell, code, search, { collapseResult = true } = {}) {
     const now = performance.now();
     const analysis = await new pipeline_executor_1.PipelineExecutor(default_pipelines_1.DEFAULT_DATAFLOW_PIPELINE, {
         parser: shell,
         request: (0, retriever_1.requestFromInput)(code)
-    }).allRemainingSteps();
-    const result = (0, flowr_search_executor_1.runSearch)(search, analysis);
+    }, config_1.defaultConfigOptions).allRemainingSteps();
+    const result = (0, flowr_search_executor_1.runSearch)(search, { ...analysis, config: config_1.defaultConfigOptions });
     const duration = performance.now() - now;
     const metaInfo = `
 The search required _${(0, time_1.printAsMs)(duration)}_ (including parsing and normalization and the query) within the generation environment.

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

@@ -10,21 +10,42 @@ export interface TypeElementInSource {
     comments?: string[];
     readonly properties?: string[];
 }
+export declare function getTypeScriptSourceFiles(fileNames: readonly string[]): {
+    files: ts.SourceFile[];
+    program: ts.Program;
+};
+export declare function dropGenericsFromTypeName(type: string): string;
+export declare function removeCommentSymbolsFromTypeScriptComment(comment: string): string;
+export declare function getTextualCommentsFromTypeScript(node: ts.Node): string[];
+export declare function getStartLineOfTypeScriptNode(node: ts.Node, sourceFile: ts.SourceFile): number;
 export declare function getType(node: ts.Node, typeChecker: ts.TypeChecker): string;
 export declare function followTypeReference(type: ts.TypeReferenceNode, sourceFile: ts.SourceFile): string[];
-export declare function getTypePathLink({ filePath, lineNumber }: TypeElementInSource, prefix?: string): string;
+export declare function getTypePathForTypeScript({ filePath }: Pick<TypeElementInSource, 'filePath'>): string;
+export declare function getTypePathLink(elem: Pick<TypeElementInSource, 'filePath' | 'lineNumber'>, prefix?: string): string;
 export interface GetTypesAsMermaidOption {
     readonly rootFolder?: string;
     readonly files?: readonly string[];
-    readonly typeName: string;
+    /** if you request a type name, we will generate a mermaid diagram for that type */
+    readonly typeNameForMermaid?: string;
     readonly inlineTypes?: readonly string[];
 }
-export interface MermaidTypeReport {
-    text: string;
+export interface TypeReport {
+    /** if you request a type name this will include the mermaid diagram for the type */
+    mermaid: string | undefined;
     info: TypeElementInSource[];
     program: ts.Program;
 }
-export declare function getTypesFromFolderAsMermaid(options: GetTypesAsMermaidOption): MermaidTypeReport;
+export declare function getTypesFromFolder(options: GetTypesAsMermaidOption & {
+    typeNameForMermaid: string;
+}): (TypeReport & {
+    mermaid: string;
+});
+export declare function getTypesFromFolder(options: GetTypesAsMermaidOption & {
+    typeNameForMermaid?: undefined;
+}): (TypeReport & {
+    mermaid: undefined;
+});
+export declare function getTypesFromFolder(options: GetTypesAsMermaidOption): TypeReport;
 export declare function implSnippet(node: TypeElementInSource | undefined, program: ts.Program, showName?: boolean, nesting?: number, open?: boolean): string;
 export interface PrintHierarchyArguments {
     readonly program: ts.Program;
@@ -51,5 +72,6 @@ export declare function printCodeOfElement({ program, info }: FnInfo, name: stri
  * @param realNameWrapper - How to highlight the function in name in the `x::y` format?
  */
 export declare function shortLink(name: string, hierarchy: readonly TypeElementInSource[], codeStyle?: boolean, realNameWrapper?: string): string;
-export declare function getDocumentationForType(name: string, hierarchy: TypeElementInSource[], prefix?: 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 {};