@eagleoutice/flowr 2.4.7 → 2.5.0

package/queries/catalog/call-context-query/call-context-query-format.d.ts

@@ -20,7 +20,7 @@ export interface FileFilter<FilterType> {
      */
     readonly includeUndefinedFiles?: boolean;
 }
-export interface DefaultCallContextQueryFormat<RegexType extends RegExp | string> extends BaseQueryFormat {
+export interface DefaultCallContextQueryFormat<RegexType extends CallNameTypes> extends BaseQueryFormat {
     readonly type: 'call-context';
     /** Regex regarding the function name, please note that strings will be interpreted as regular expressions too! */
     readonly callName: RegexType;
@@ -50,13 +50,14 @@ export interface DefaultCallContextQueryFormat<RegexType extends RegExp | string
      */
     readonly fileFilter?: FileFilter<RegexType>;
 }
+export type CallNameTypes = RegExp | string | string[];
 /**
  * Links the current call to the last call of the given kind.
  * This way, you can link a call like `points` to the latest graphics plot etc.
  * For now, this uses the static Control-Flow-Graph produced by flowR as the FD over-approximation is still not stable (see #1005).
  * In short, this means that we are unable to detect origins over function call boundaries but plan on being more precise in the future.
  */
-export interface LinkToLastCall<CallName extends RegExp | string = RegExp | string> extends BaseQueryFormat {
+export interface LinkToLastCall<CallName extends CallNameTypes = CallNameTypes> extends BaseQueryFormat {
     readonly type: 'link-to-last-call';
     /** Regex regarding the function name of the last call. Similar to {@link DefaultCallContextQueryFormat#callName}, strings are interpreted as a `RegExp`. */
     readonly callName: CallName;
@@ -71,10 +72,10 @@ export interface LinkToLastCall<CallName extends RegExp | string = RegExp | stri
      */
     readonly cascadeIf?: (target: DataflowGraphVertexInfo, from: NodeId, graph: DataflowGraph) => CascadeAction;
 }
-export type LinkTo<CallName extends RegExp | string = RegExp | string, AttachLinkInfo = NoInfo> = (LinkToLastCall<CallName>) & {
+export type LinkTo<CallName extends CallNameTypes = CallNameTypes, AttachLinkInfo = NoInfo> = (LinkToLastCall<CallName>) & {
     attachLinkInfo?: AttachLinkInfo;
 };
-export interface SubCallContextQueryFormat<CallName extends RegExp | string = RegExp | string, AttachLinkInfo = NoInfo> extends DefaultCallContextQueryFormat<CallName> {
+export interface SubCallContextQueryFormat<CallName extends CallNameTypes = CallNameTypes, AttachLinkInfo = NoInfo> extends DefaultCallContextQueryFormat<CallName> {
     readonly linkTo: LinkTo<CallName, AttachLinkInfo> | LinkTo<CallName, AttachLinkInfo>[];
 }
 export interface CallContextQuerySubKindResult {
@@ -105,7 +106,7 @@ export type CallContextQueryKindResult = Record<string, {
 export interface CallContextQueryResult extends BaseQueryResult {
     readonly kinds: CallContextQueryKindResult;
 }
-export type CallContextQuery<CallName extends RegExp | string = RegExp | string, AttachLinkInfo = NoInfo> = DefaultCallContextQueryFormat<CallName> | SubCallContextQueryFormat<CallName, AttachLinkInfo>;
+export type CallContextQuery<CallName extends CallNameTypes = CallNameTypes, AttachLinkInfo = NoInfo> = DefaultCallContextQueryFormat<CallName> | SubCallContextQueryFormat<CallName, AttachLinkInfo>;
 export declare const CallContextQueryDefinition: {
     readonly executor: typeof executeCallContextQueries;
     readonly asciiSummarizer: (formatter: OutputFormatter, processed: PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>, queryResults: BaseQueryResult, result: string[]) => boolean;

package/queries/catalog/call-context-query/call-context-query-format.js

@@ -12,7 +12,7 @@ const query_print_1 = require("../../query-print");
 const identify_link_to_last_call_relation_1 = require("./identify-link-to-last-call-relation");
 const CallContextQueryLinkTo = joi_1.default.object({
     type: joi_1.default.string().valid('link-to-last-call').required().description('The type of the linkTo sub-query.'),
-    callName: joi_1.default.string().required().description('Regex regarding the function name of the last call. Similar to `callName`, strings are interpreted as a regular expression.'),
+    callName: joi_1.default.alternatives(joi_1.default.string(), joi_1.default.array().items(joi_1.default.string())).required().description('Test regarding the function name of the last call. Similar to `callName`, strings are interpreted as a regular expression, and string arrays are checked for containment.'),
     ignoreIf: joi_1.default.function().optional().description('Should we ignore this (source) call? Currently, there is no well working serialization for this.'),
     cascadeIf: joi_1.default.function().optional().description('Should we continue searching after the link was created? Currently, there is no well working serialization for this.'),
     attachLinkInfo: joi_1.default.object().optional().description('Additional information to attach to the link.')

package/queries/catalog/call-context-query/identify-link-to-last-call-relation.d.ts

@@ -5,6 +5,7 @@ import { RType } from '../../../r-bridge/lang-4.x/ast/model/type';
 import type { RNodeWithParent } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { LinkTo } from './call-context-query-format';
 import type { ControlFlowGraph } from '../../../control-flow/control-flow-graph';
+import type { PromotedLinkTo } from './call-context-query-executor';
 export declare enum CallTargets {
     /** call targets a function that is not defined locally in the script (e.g., the call targets a library function) */
     OnlyGlobal = "global",
@@ -24,4 +25,4 @@ export declare function getValueOfArgument<Types extends readonly RType[] = read
 }, additionalAllowedTypes?: Types): (RNodeWithParent & {
     type: Types[number];
 }) | undefined;
-export declare function identifyLinkToLastCallRelation(from: NodeId, cfg: ControlFlowGraph, graph: DataflowGraph, { callName, ignoreIf, cascadeIf }: LinkTo<RegExp>): NodeId[];
+export declare function identifyLinkToLastCallRelation(from: NodeId, cfg: ControlFlowGraph, graph: DataflowGraph, { callName, ignoreIf, cascadeIf }: LinkTo<RegExp> | PromotedLinkTo): NodeId[];

package/queries/catalog/call-context-query/identify-link-to-last-call-relation.js

@@ -121,7 +121,7 @@ function identifyLinkToLastCallRelation(from, cfg, graph, { callName, ignoreIf,
         if (vertex === undefined || vertex.tag !== vertex_1.VertexType.FunctionCall) {
             return;
         }
-        if (callName.test(vertex.name)) {
+        if (callName instanceof RegExp ? callName.test(vertex.name) : callName.has(vertex.name)) {
             const act = cascadeIf ? cascadeIf(vertex, from, graph) : cascade_action_1.CascadeAction.Stop;
             if (act === cascade_action_1.CascadeAction.Skip) {
                 return;

package/queries/catalog/config-query/config-query-executor.js

@@ -2,9 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeConfigQuery = executeConfigQuery;
 const log_1 = require("../../../util/log");
+const assert_1 = require("../../../util/assert");
+const objects_1 = require("../../../util/objects");
 function executeConfigQuery({ config }, queries) {
     if (queries.length !== 1) {
-        log_1.log.warn('Config query expects only up to one query, but got', queries.length);
+        log_1.log.warn('Config query usually expects only up to one query, but got', queries.length);
+    }
+    const updates = queries.map(q => q.update).filter(assert_1.isNotUndefined);
+    for (const update of updates) {
+        (0, objects_1.deepMergeObjectInPlace)(config, update);
     }
     return {
         '.meta': {

package/queries/catalog/config-query/config-query-format.d.ts

@@ -3,15 +3,22 @@ import { executeConfigQuery } from './config-query-executor';
 import { type OutputFormatter } from '../../../util/text/ansi';
 import Joi from 'joi';
 import type { FlowrConfigOptions } from '../../../config';
+import type { DeepPartial } from 'ts-essentials';
 export interface ConfigQuery extends BaseQueryFormat {
     readonly type: 'config';
+    readonly update?: DeepPartial<FlowrConfigOptions>;
 }
 export interface ConfigQueryResult extends BaseQueryResult {
     readonly config: FlowrConfigOptions;
 }
+declare function configReplCompleter(partialLine: readonly string[], config: FlowrConfigOptions): string[];
+declare function configQueryLineParser(line: readonly string[], _config: FlowrConfigOptions): [ConfigQuery];
 export declare const ConfigQueryDefinition: {
     readonly executor: typeof executeConfigQuery;
     readonly asciiSummarizer: (formatter: OutputFormatter, _processed: unknown, queryResults: BaseQueryResult, result: string[]) => boolean;
+    readonly completer: typeof configReplCompleter;
+    readonly fromLine: typeof configQueryLineParser;
     readonly schema: Joi.ObjectSchema<any>;
     readonly flattenInvolvedNodes: () => never[];
 };
+export {};

package/queries/catalog/config-query/config-query-format.js

@@ -9,6 +9,74 @@ const ansi_1 = require("../../../util/text/ansi");
 const time_1 = require("../../../util/text/time");
 const joi_1 = __importDefault(require("joi"));
 const json_1 = require("../../../util/json");
+function configReplCompleter(partialLine, config) {
+    if (partialLine.length === 0) {
+        // update specific fields
+        return ['+'];
+    }
+    else if (partialLine.length === 1 && partialLine[0].startsWith('+')) {
+        const path = partialLine[0].slice(1).split('.').filter(p => p.length > 0);
+        const fullPath = path.slice();
+        const lastPath = partialLine[0].endsWith('.') ? '' : path.pop() ?? '';
+        if (lastPath.endsWith('=')) {
+            return [];
+        }
+        const subConfig = path.reduce((obj, key) => (obj && obj[key] !== undefined && typeof obj[key] === 'object') ? obj[key] : obj, config);
+        if (subConfig && !(subConfig[lastPath] !== undefined && typeof subConfig[lastPath] !== 'object')) {
+            const have = Object.keys(subConfig)
+                .filter(k => k.startsWith(lastPath) && k !== lastPath)
+                .map(k => `${partialLine[0].slice(0, 1)}${[...path, k].join('.')}`);
+            if (have.length > 0) {
+                return have;
+            }
+            else if (lastPath.length > 0) {
+                return [`${partialLine[0].slice(0, 1)}${fullPath.join('.')}.`];
+            }
+        }
+        return [`${partialLine[0].slice(0, 1)}${fullPath.join('.')}=`];
+    }
+    return [];
+}
+function configQueryLineParser(line, _config) {
+    if (line.length > 0 && line[0].startsWith('+')) {
+        const [pathPart, ...valueParts] = line[0].slice(1).split('=');
+        // build the update object
+        const path = pathPart.split('.').filter(p => p.length > 0);
+        if (path.length === 0 || valueParts.length !== 1) {
+            console.error('Invalid config update syntax, must be of the form +path.to.field=value');
+        }
+        else {
+            const update = {};
+            const value = valueParts[0];
+            let current = update;
+            for (let i = 0; i < path.length; i++) {
+                const key = path[i];
+                if (i === path.length - 1) {
+                    // last part, set the value
+                    // try to parse as JSON first
+                    try {
+                        current[key] = JSON.parse(value);
+                    }
+                    catch {
+                        // fallback to string
+                        current[key] = value;
+                    }
+                }
+                else {
+                    current[key] = {};
+                    current = current[key];
+                }
+            }
+            return [{
+                    type: 'config',
+                    update
+                }];
+        }
+    }
+    return [{
+            type: 'config'
+        }];
+}
 exports.ConfigQueryDefinition = {
     executor: config_query_executor_1.executeConfigQuery,
     asciiSummarizer: (formatter, _processed, queryResults, result) => {
@@ -17,9 +85,12 @@ exports.ConfigQueryDefinition = {
         result.push(`   ╰ Config:\n${JSON.stringify(out.config, json_1.jsonReplacer, 4)}`);
         return true;
     },
+    completer: configReplCompleter,
+    fromLine: configQueryLineParser,
     schema: joi_1.default.object({
         type: joi_1.default.string().valid('config').required().description('The type of the query.'),
-    }).description('The config query retrieves the current configuration of the flowR instance.'),
+        update: joi_1.default.object().optional().description('An optional partial configuration to update the current configuration with before returning it. Only the provided fields will be updated, all other fields will remain unchanged.')
+    }).description('The config query retrieves the current configuration of the flowR instance and optionally also updates it.'),
     flattenInvolvedNodes: () => []
 };
 //# sourceMappingURL=config-query-format.js.map

package/queries/catalog/dependencies-query/dependencies-query-executor.js

@@ -6,29 +6,11 @@ const dependencies_query_format_1 = require("./dependencies-query-format");
 const vertex_1 = require("../../../dataflow/graph/vertex");
 const log_1 = require("../../../util/log");
 const type_1 = require("../../../r-bridge/lang-4.x/ast/model/type");
-const visitor_1 = require("../../../r-bridge/lang-4.x/ast/model/processing/visitor");
 const objects_1 = require("../../../util/objects");
-const library_functions_1 = require("./function-info/library-functions");
-const source_functions_1 = require("./function-info/source-functions");
-const read_functions_1 = require("./function-info/read-functions");
-const write_functions_1 = require("./function-info/write-functions");
 const function_info_1 = require("./function-info/function-info");
 const identify_link_to_last_call_relation_1 = require("../call-context-query/identify-link-to-last-call-relation");
 const resolve_argument_1 = require("../../../dataflow/eval/resolve/resolve-argument");
 const assert_1 = require("../../../util/assert");
-function collectNamespaceAccesses(data, libraries) {
-    /* for libraries, we have to additionally track all uses of `::` and `:::`, for this we currently simply traverse all uses */
-    (0, visitor_1.visitAst)(data.ast.ast, n => {
-        if (n.type === type_1.RType.Symbol && n.namespace) {
-            /* we should improve the identification of ':::' */
-            libraries.push({
-                nodeId: n.info.id,
-                functionName: (n.info.fullLexeme ?? n.lexeme).includes(':::') ? ':::' : '::',
-                libraryName: n.namespace,
-            });
-        }
-    });
-}
 function executeDependenciesQuery(data, queries) {
     if (queries.length !== 1) {
         log_1.log.warn('Dependencies query expects only up to one query, but got ', queries.length, 'only using the first query');
@@ -36,64 +18,28 @@ function executeDependenciesQuery(data, queries) {
     const now = Date.now();
     const [query] = queries;
     const ignoreDefault = query.ignoreDefaultFunctions ?? false;
-    const libraryFunctions = getFunctionsToCheck(query.libraryFunctions, ignoreDefault, library_functions_1.LibraryFunctions);
-    const sourceFunctions = getFunctionsToCheck(query.sourceFunctions, ignoreDefault, source_functions_1.SourceFunctions);
-    const readFunctions = getFunctionsToCheck(query.readFunctions, ignoreDefault, read_functions_1.ReadFunctions);
-    const writeFunctions = getFunctionsToCheck(query.writeFunctions, ignoreDefault, write_functions_1.WriteFunctions);
-    const numberOfFunctions = libraryFunctions.length + sourceFunctions.length + readFunctions.length + writeFunctions.length;
-    const results = numberOfFunctions === 0 ? { kinds: {}, '.meta': { timing: 0 } } : (0, query_1.executeQueriesOfSameType)(data, [
-        makeCallContextQuery(libraryFunctions, 'library'),
-        makeCallContextQuery(sourceFunctions, 'source'),
-        makeCallContextQuery(readFunctions, 'read'),
-        makeCallContextQuery(writeFunctions, 'write')
-    ].flat());
-    function getLexeme(argument, id) {
-        if ((argument && argument !== dependencies_query_format_1.Unknown) || !id) {
-            return undefined;
-        }
-        let get = data.ast.idMap.get(id);
-        if (get?.type === type_1.RType.Argument) {
-            get = get.value;
-        }
-        return get?.info.fullLexeme ?? get?.lexeme;
-    }
-    const libraries = getResults(data, results, 'library', libraryFunctions, (id, vertex, argId, value, linkedIds) => ({
-        nodeId: id,
-        functionName: vertex.name,
-        lexemeOfArgument: getLexeme(value, argId),
-        libraryName: value ?? dependencies_query_format_1.Unknown,
-        linkedIds: linkedIds?.length ? linkedIds : undefined
+    const functions = new Map(Object.entries(dependencies_query_format_1.DefaultDependencyCategories).map(([c, v]) => {
+        return [c, getFunctionsToCheck(query[`${c}Functions`], c, query.enabledCategories, ignoreDefault, v.functions)];
     }));
-    if (!ignoreDefault) {
-        collectNamespaceAccesses(data, libraries);
+    if (query.additionalCategories !== undefined) {
+        for (const [category, value] of Object.entries(query.additionalCategories)) {
+            // custom categories only use the "functions" collection and do not allow specifying additional functions in the object itself, so we "undefined" a lot here
+            functions.set(category, getFunctionsToCheck(undefined, category, undefined, false, value.functions));
+        }
     }
-    const sourcedFiles = getResults(data, results, 'source', sourceFunctions, (id, vertex, argId, value, linkedIds) => ({
-        nodeId: id,
-        functionName: vertex.name,
-        file: value ?? dependencies_query_format_1.Unknown,
-        lexemeOfArgument: getLexeme(value, argId),
-        linkedIds: linkedIds?.length ? linkedIds : undefined
-    }));
-    const readData = getResults(data, results, 'read', readFunctions, (id, vertex, argId, value, linkedIds) => ({
-        nodeId: id,
-        functionName: vertex.name,
-        source: value ?? dependencies_query_format_1.Unknown,
-        lexemeOfArgument: getLexeme(value, argId),
-        linkedIds: linkedIds?.length ? linkedIds : undefined
-    }));
-    const writtenData = getResults(data, results, 'write', writeFunctions, (id, vertex, argId, value, linkedIds) => ({
-        nodeId: id,
-        functionName: vertex.name,
-        // write functions that don't have argIndex are assumed to write to stdout
-        destination: value ?? 'stdout',
-        lexemeOfArgument: getLexeme(value, argId),
-        linkedIds: linkedIds?.length ? linkedIds : undefined
+    const queryResults = functions.values().toArray().flat().length === 0 ? { kinds: {}, '.meta': { timing: 0 } } :
+        (0, query_1.executeQueriesOfSameType)(data, functions.entries().map(([c, f]) => makeCallContextQuery(f, c)).toArray().flat());
+    const results = Object.fromEntries(functions.entries().map(([c, f]) => {
+        const results = getResults(queries, data, queryResults, c, f);
+        // only default categories allow additional analyses, so we null coalese here!
+        dependencies_query_format_1.DefaultDependencyCategories[c]?.additionalAnalysis?.(data, ignoreDefault, f, queryResults, results);
+        return [c, results];
     }));
     return {
         '.meta': {
             timing: Date.now() - now
         },
-        libraries, sourcedFiles, readData, writtenData
+        ...results
     };
 }
 function makeCallContextQuery(functions, kind) {
@@ -116,19 +62,28 @@ function dropInfoOnLinkedIds(linkedIds) {
 }
 const readOnlyModes = new Set(['r', 'rt', 'rb']);
 const writeOnlyModes = new Set(['w', 'wt', 'wb', 'a', 'at', 'ab']);
-function getResults(data, results, kind, functions, makeInfo) {
+function getResults(queries, data, results, kind, functions) {
+    const defaultValue = (0, dependencies_query_format_1.getAllCategories)(queries)[kind].defaultValue;
+    const functionMap = new Map(functions.map(f => [f.name, f]));
     const kindEntries = Object.entries(results?.kinds[kind]?.subkinds ?? {});
     return kindEntries.flatMap(([name, results]) => results.flatMap(({ id, linkedIds }) => {
         const vertex = data.dataflow.graph.getVertex(id);
-        const info = functions.find(f => f.name === name);
+        const info = functionMap.get(name);
         const args = (0, resolve_argument_1.getArgumentStringValue)(data.config.solver.variables, data.dataflow.graph, vertex, info.argIdx, info.argName, info.resolveValue);
         const linkedArgs = collectValuesFromLinks(args, data, linkedIds);
+        const linked = dropInfoOnLinkedIds(linkedIds);
         const foundValues = linkedArgs ?? args;
         if (!foundValues) {
             if (info.ignoreIf === 'arg-missing') {
                 return [];
             }
-            const record = (0, objects_1.compactRecord)(makeInfo(id, vertex, undefined, undefined, dropInfoOnLinkedIds(linkedIds)));
+            const record = (0, objects_1.compactRecord)({
+                nodeId: id,
+                functionName: vertex.name,
+                lexemeOfArgument: undefined,
+                linkedIds: linked?.length ? linked : undefined,
+                value: defaultValue
+            });
             return record ? [record] : [];
         }
         else if (info.ignoreIf === 'mode-only-read' || info.ignoreIf === 'mode-only-write') {
@@ -136,7 +91,7 @@ function getResults(data, results, kind, functions, makeInfo) {
             const margs = info.additionalArgs?.mode;
             (0, assert_1.guard)(margs, 'Need additional argument mode when checking for mode');
             const modeArgs = (0, resolve_argument_1.getArgumentStringValue)(data.config.solver.variables, data.dataflow.graph, vertex, margs.argIdx, margs.argName, margs.resolveValue);
-            const modeValues = [...modeArgs?.values() ?? []].flatMap(v => [...v]) ?? [];
+            const modeValues = modeArgs?.values().flatMap(v => [...v]) ?? [];
             if (info.ignoreIf === 'mode-only-read' && modeValues.every(m => m && readOnlyModes.has(m))) {
                 // all modes are read-only, so we can ignore this
                 return [];
@@ -149,7 +104,13 @@ function getResults(data, results, kind, functions, makeInfo) {
         const results = [];
         for (const [arg, values] of foundValues.entries()) {
             for (const value of values) {
-                const result = (0, objects_1.compactRecord)(makeInfo(id, vertex, arg, value, dropInfoOnLinkedIds(linkedIds)));
+                const result = (0, objects_1.compactRecord)({
+                    nodeId: id,
+                    functionName: vertex.name,
+                    lexemeOfArgument: getLexeme(value, arg),
+                    linkedIds: linked?.length ? linked : undefined,
+                    value: value ?? defaultValue
+                });
                 if (result) {
                     results.push(result);
                 }
@@ -157,6 +118,16 @@ function getResults(data, results, kind, functions, makeInfo) {
         }
         return results;
     })) ?? [];
+    function getLexeme(argument, id) {
+        if ((argument && argument !== dependencies_query_format_1.Unknown) || !id) {
+            return undefined;
+        }
+        let get = data.ast.idMap.get(id);
+        if (get?.type === type_1.RType.Argument) {
+            get = get.value;
+        }
+        return get?.info.fullLexeme ?? get?.lexeme;
+    }
 }
 function collectValuesFromLinks(args, data, linkedIds) {
     if (!linkedIds || linkedIds.length === 0) {
@@ -192,7 +163,11 @@ function collectValuesFromLinks(args, data, linkedIds) {
     }
     return map.size ? map : undefined;
 }
-function getFunctionsToCheck(customFunctions, ignoreDefaultFunctions, defaultFunctions) {
+function getFunctionsToCheck(customFunctions, functionFlag, enabled, ignoreDefaultFunctions, defaultFunctions) {
+    // "If unset or empty, all function types are searched for."
+    if (enabled?.length && enabled.indexOf(functionFlag) < 0) {
+        return [];
+    }
     let functions = ignoreDefaultFunctions ? [] : [...defaultFunctions];
     if (customFunctions) {
         functions = functions.concat(customFunctions);

package/queries/catalog/dependencies-query/dependencies-query-format.d.ts

@@ -1,42 +1,66 @@
-import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
+import type { BaseQueryFormat, BaseQueryResult, BasicQueryData } from '../../base-query-format';
 import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import Joi from 'joi';
 import { executeDependenciesQuery } from './dependencies-query-executor';
 import type { FunctionInfo } from './function-info/function-info';
+import type { CallContextQueryResult } from '../call-context-query/call-context-query-format';
 export declare const Unknown = "unknown";
-export interface DependenciesQuery extends BaseQueryFormat {
+export interface DependencyCategorySettings {
+    queryDisplayName?: string;
+    functions: FunctionInfo[];
+    defaultValue?: string;
+    additionalAnalysis?: (data: BasicQueryData, ignoreDefault: boolean, functions: FunctionInfo[], queryResults: CallContextQueryResult, result: DependencyInfo[]) => void;
+}
+export declare const DefaultDependencyCategories: {
+    readonly library: {
+        readonly queryDisplayName: "Libraries";
+        readonly functions: FunctionInfo[];
+        readonly defaultValue: "unknown";
+        readonly additionalAnalysis: (data: BasicQueryData, ignoreDefault: boolean, _functions: FunctionInfo[], _queryResults: CallContextQueryResult, result: DependencyInfo[]) => void;
+    };
+    readonly source: {
+        readonly queryDisplayName: "Sourced Files";
+        readonly functions: FunctionInfo[];
+        readonly defaultValue: "unknown";
+    };
+    readonly read: {
+        readonly queryDisplayName: "Read Data";
+        readonly functions: FunctionInfo[];
+        readonly defaultValue: "unknown";
+    };
+    readonly write: {
+        readonly queryDisplayName: "Written Data";
+        readonly functions: FunctionInfo[];
+        readonly defaultValue: "stdout";
+    };
+    readonly visualize: {
+        readonly queryDisplayName: "Visualizations";
+        readonly functions: FunctionInfo[];
+    };
+};
+export type DefaultDependencyCategoryName = keyof typeof DefaultDependencyCategories;
+export type DependencyCategoryName = DefaultDependencyCategoryName | string;
+export interface DependenciesQuery extends BaseQueryFormat, Partial<Record<`${DefaultDependencyCategoryName}Functions`, FunctionInfo[]>> {
     readonly type: 'dependencies';
+    readonly enabledCategories?: DependencyCategoryName[];
     readonly ignoreDefaultFunctions?: boolean;
-    readonly libraryFunctions?: FunctionInfo[];
-    readonly sourceFunctions?: FunctionInfo[];
-    readonly readFunctions?: FunctionInfo[];
-    readonly writeFunctions?: FunctionInfo[];
-}
-export interface DependenciesQueryResult extends BaseQueryResult {
-    libraries: LibraryInfo[];
-    sourcedFiles: SourceInfo[];
-    readData: ReadInfo[];
-    writtenData: WriteInfo[];
+    readonly additionalCategories?: Record<string, Omit<DependencyCategorySettings, 'additionalAnalysis'>>;
 }
+export type DependenciesQueryResult = BaseQueryResult & {
+    [C in DefaultDependencyCategoryName]: DependencyInfo[];
+} & {
+    [S in string]?: DependencyInfo[];
+};
 export interface DependencyInfo extends Record<string, unknown> {
     nodeId: NodeId;
     functionName: string;
     linkedIds?: readonly NodeId[];
     /** the lexeme is presented whenever the specific info is of {@link Unknown} */
     lexemeOfArgument?: string;
+    /** The library name, file, source, destination etc. being sourced, read from, or written to. */
+    value?: string;
 }
-export type LibraryInfo = (DependencyInfo & {
-    libraryName: 'unknown' | string;
-});
-export type SourceInfo = (DependencyInfo & {
-    file: string;
-});
-export type ReadInfo = (DependencyInfo & {
-    source: string;
-});
-export type WriteInfo = (DependencyInfo & {
-    destination: 'stdout' | string;
-});
+export declare function getAllCategories(queries: readonly DependenciesQuery[]): Record<DependencyCategoryName, DependencyCategorySettings>;
 export declare const DependenciesQueryDefinition: {
     readonly executor: typeof executeDependenciesQuery;
     readonly asciiSummarizer: (formatter: import("../../../util/text/ansi").OutputFormatter, _processed: import("../../../core/steps/pipeline/pipeline").PipelineOutput<import("../../../core/steps/pipeline/pipeline").Pipeline<{
@@ -92,7 +116,7 @@ export declare const DependenciesQueryDefinition: {
             readonly 4: typeof import("../../../core/print/dataflow-printer").dataflowGraphToMermaidUrl;
         };
         readonly dependencies: readonly ["normalize"];
-    }>>, queryResults: BaseQueryResult, result: string[]) => true;
+    }>>, queryResults: BaseQueryResult, result: string[], queries: readonly import("../../query").Query[]) => true;
     readonly schema: Joi.ObjectSchema<any>;
-    readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
+    readonly flattenInvolvedNodes: (queryResults: BaseQueryResult, query: readonly import("../../query").Query[]) => NodeId[];
 };

package/queries/catalog/dependencies-query/dependencies-query-format.js

@@ -3,13 +3,62 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DependenciesQueryDefinition = exports.Unknown = void 0;
+exports.DependenciesQueryDefinition = exports.DefaultDependencyCategories = exports.Unknown = void 0;
+exports.getAllCategories = getAllCategories;
 const ansi_1 = require("../../../util/text/ansi");
 const time_1 = require("../../../util/text/time");
 const joi_1 = __importDefault(require("joi"));
 const dependencies_query_executor_1 = require("./dependencies-query-executor");
+const library_functions_1 = require("./function-info/library-functions");
+const source_functions_1 = require("./function-info/source-functions");
+const read_functions_1 = require("./function-info/read-functions");
+const write_functions_1 = require("./function-info/write-functions");
+const visualize_functions_1 = require("./function-info/visualize-functions");
+const visitor_1 = require("../../../r-bridge/lang-4.x/ast/model/processing/visitor");
+const type_1 = require("../../../r-bridge/lang-4.x/ast/model/type");
 exports.Unknown = 'unknown';
-function printResultSection(title, infos, result, sectionSpecifics) {
+exports.DefaultDependencyCategories = {
+    'library': {
+        queryDisplayName: 'Libraries',
+        functions: library_functions_1.LibraryFunctions,
+        defaultValue: exports.Unknown,
+        /* for libraries, we have to additionally track all uses of `::` and `:::`, for this we currently simply traverse all uses */
+        additionalAnalysis: (data, ignoreDefault, _functions, _queryResults, result) => {
+            if (!ignoreDefault) {
+                (0, visitor_1.visitAst)(data.ast.ast, n => {
+                    if (n.type === type_1.RType.Symbol && n.namespace) {
+                        /* we should improve the identification of ':::' */
+                        result.push({
+                            nodeId: n.info.id,
+                            functionName: (n.info.fullLexeme ?? n.lexeme).includes(':::') ? ':::' : '::',
+                            value: n.namespace,
+                        });
+                    }
+                });
+            }
+        }
+    },
+    'source': {
+        queryDisplayName: 'Sourced Files',
+        functions: source_functions_1.SourceFunctions,
+        defaultValue: exports.Unknown
+    },
+    'read': {
+        queryDisplayName: 'Read Data',
+        functions: read_functions_1.ReadFunctions,
+        defaultValue: exports.Unknown
+    },
+    'write': {
+        queryDisplayName: 'Written Data',
+        functions: write_functions_1.WriteFunctions,
+        defaultValue: 'stdout'
+    },
+    'visualize': {
+        queryDisplayName: 'Visualizations',
+        functions: visualize_functions_1.VisualizeFunctions
+    }
+};
+function printResultSection(title, infos, result) {
     if (infos.length <= 0) {
         return;
     }
@@ -26,9 +75,18 @@ function printResultSection(title, infos, result, sectionSpecifics) {
     }, new Map());
     for (const [functionName, infos] of grouped) {
         result.push(`       ╰ \`${functionName}\``);
-        result.push(infos.map(i => `           ╰ Node Id: ${i.nodeId}, ${sectionSpecifics(i)}`).join('\n'));
+        result.push(infos.map(i => `           ╰ Node Id: ${i.nodeId}${i.value !== undefined ? `, \`${i.value}\`` : ''}`).join('\n'));
     }
 }
+function getAllCategories(queries) {
+    let categories = exports.DefaultDependencyCategories;
+    for (const query of queries) {
+        if (query.additionalCategories) {
+            categories = { ...categories, ...query.additionalCategories };
+        }
+    }
+    return categories;
+}
 const functionInfoSchema = joi_1.default.array().items(joi_1.default.object({
     name: joi_1.default.string().required().description('The name of the library function.'),
     package: joi_1.default.string().optional().description('The package name of the library function'),
@@ -37,31 +95,28 @@ const functionInfoSchema = joi_1.default.array().items(joi_1.default.object({
 })).optional();
 exports.DependenciesQueryDefinition = {
     executor: dependencies_query_executor_1.executeDependenciesQuery,
-    asciiSummarizer: (formatter, _processed, queryResults, result) => {
+    asciiSummarizer: (formatter, _processed, queryResults, result, queries) => {
         const out = queryResults;
         result.push(`Query: ${(0, ansi_1.bold)('dependencies', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
-        printResultSection('Libraries', out.libraries, result, l => `\`${l.libraryName}\``);
-        printResultSection('Sourced Files', out.sourcedFiles, result, s => `\`${s.file}\``);
-        printResultSection('Read Data', out.readData, result, r => `\`${r.source}\``);
-        printResultSection('Written Data', out.writtenData, result, w => `\`${w.destination}\``);
+        for (const [category, value] of Object.entries(getAllCategories(queries))) {
+            printResultSection(value.queryDisplayName ?? category, out[category] ?? [], result);
+        }
         return true;
     },
     schema: joi_1.default.object({
         type: joi_1.default.string().valid('dependencies').required().description('The type of the query.'),
-        ignoreDefaultFunctions: joi_1.default.boolean().optional().description('Should the set of functions that are detected by default be ignored/skipped?'),
-        libraryFunctions: functionInfoSchema.description('The set of library functions to search for.'),
-        sourceFunctions: functionInfoSchema.description('The set of source functions to search for.'),
-        readFunctions: functionInfoSchema.description('The set of data reading functions to search for.'),
-        writeFunctions: functionInfoSchema.description('The set of data writing functions to search for.'),
+        ignoreDefaultFunctions: joi_1.default.boolean().optional().description('Should the set of functions that are detected by default be ignored/skipped? Defaults to false.'),
+        ...Object.fromEntries(Object.keys(exports.DefaultDependencyCategories).map(c => [`${c}Functions`, functionInfoSchema.description(`The set of ${c} functions to search for.`)])),
+        enabledCategories: joi_1.default.array().optional().items(joi_1.default.string().valid(...Object.keys(exports.DefaultDependencyCategories))).description('A set of flags that determines what types of dependencies are searched for. If unset or empty, all dependency types are searched for.'),
+        additionalCategories: joi_1.default.object().allow(joi_1.default.object({
+            queryDisplayName: joi_1.default.string().description('The display name in the query result.'),
+            functions: functionInfoSchema.description('The functions that this additional category should search for.'),
+            defaultValue: joi_1.default.string().description('The default value to return when there is no value to gather from the function information.').optional()
+        })).description('A set of additional, user-supplied dependency categories, whose results will be included in the query return value.').optional()
     }).description('The dependencies query retrieves and returns the set of all dependencies in the dataflow graph, which includes libraries, sourced files, read data, and written data.'),
-    flattenInvolvedNodes: (queryResults) => {
+    flattenInvolvedNodes: (queryResults, query) => {
         const out = queryResults;
-        return [
-            ...out.libraries.map(library => library.nodeId),
-            ...out.sourcedFiles.map(sourced => sourced.nodeId),
-            ...out.readData.map(read => read.nodeId),
-            ...out.writtenData.map(write => write.nodeId)
-        ];
+        return Object.keys(getAllCategories(query)).flatMap(c => out[c] ?? []).map(o => o.nodeId);
     }
 };
 //# sourceMappingURL=dependencies-query-format.js.map