@eagleoutice/flowr 2.0.25 → 2.1.0

package/documentation/print-query-wiki.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const shell_1 = require("../r-bridge/shell");
+const doc_dfg_1 = require("./doc-util/doc-dfg");
+const log_1 = require("../../test/functionality/_helper/log");
+const query_1 = require("../queries/query");
+const doc_files_1 = require("./doc-util/doc-files");
+const doc_query_1 = require("./doc-util/doc-query");
+const call_context_query_format_1 = require("../queries/call-context-query/call-context-query-format");
+const schema_1 = require("../util/schema");
+const query_schema_1 = require("../queries/query-schema");
+const ansi_1 = require("../util/ansi");
+const call_context_query_executor_1 = require("../queries/call-context-query/call-context-query-executor");
+const compound_query_1 = require("../queries/virtual-query/compound-query");
+const doc_auto_gen_1 = require("./doc-util/doc-auto-gen");
+const example_query_code_1 = require("./data/query/example-query-code");
+const doc_structure_1 = require("./doc-util/doc-structure");
+const doc_code_1 = require("./doc-util/doc-code");
+(0, doc_query_1.registerQueryDocumentation)('call-context', {
+    name: 'Call-Context Query',
+    type: 'active',
+    shortDescription: 'Finds all calls in a set of files that matches specified criteria.',
+    functionName: call_context_query_executor_1.executeCallContextQueries.name,
+    functionFile: '../queries/call-context-query/call-context-query-executor.ts',
+    buildExplanation: async (shell) => {
+        return `
+Call context queries may be used to identify calls to specific functions that match criteria of your interest.
+For now, we support two criteria:
+
+1. **Function Name** (\`callName\`): The function name is specified by a regular expression. This allows you to find all calls to functions that match a specific pattern.
+2. **Call Targets**  (\`callTargets\`): This specifies to what the function call targets. For example, you may want to find all calls to a function that is not defined locally.
+
+Besides this we provide the following ways to automatically categorize and link identified invocations:
+
+1. **Kind**         (\`kind\`): This is a general category that can be used to group calls together. For example, you may want to link all calls to \`plot\` to \`visualize\`.
+2. **Subkind**      (\`subkind\`): This is used to uniquely identify the respective call type when grouping the output. For example, you may want to link all calls to \`ggplot\` to \`plot\`.
+3. **Linked Calls** (\`linkTo\`): This 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, we _only_offer support for linking to the last call_ as the current flow dependency over-approximation is not stable.
+4. **Aliases**      (\`includeAliases\`): Consider a case like \`f <- function_of_interest\`, do you want calls to \`f\` to be included in the results? There is probably no need to combine this with a global call target!
+
+Re-using the example code from above, the following query attaches all calls to \`mean\` to the kind \`visualize\` and the subkind \`text\`,
+all calls that start with \`read_\` to the kind \`input\` but only if they are not locally overwritten, and the subkind \`csv-file\`, and links all calls to \`points\` to the last call to \`plot\`:
+
+${await (0, doc_query_1.showQuery)(shell, example_query_code_1.exampleQueryCode, [
+            { type: 'call-context', callName: '^mean$', kind: 'visualize', subkind: 'text' },
+            {
+                type: 'call-context',
+                callName: '^read_',
+                kind: 'input',
+                subkind: 'csv-file',
+                callTargets: call_context_query_format_1.CallTargets.OnlyGlobal
+            },
+            {
+                type: 'call-context',
+                callName: '^points$',
+                kind: 'visualize',
+                subkind: 'plot',
+                linkTo: { type: 'link-to-last-call', callName: '^plot$' }
+            }
+        ], { showCode: false })}
+
+As you can see, all kinds and subkinds with the same name are grouped together.
+Yet, re-stating common arguments and kinds may be cumbersome (although you can already use clever regex patterns).
+See the [Compound Query](#compound-query) for a way to structure your queries more compactly if you think it gets too verbose. 
+
+${await (async () => {
+            const code = `
+foo <- my_test_function
+foo()
+if(u) bar <- foo
+bar()
+my_test_function()
+`.trim();
+            return (0, doc_structure_1.details)('Alias Example', `Consider the following code: ${(0, doc_code_1.codeBlock)('r', code)}\nNow let's say we want to query _all_ uses of the \`my_test_function\`:` + await (0, doc_query_1.showQuery)(shell, code, [
+                { type: 'call-context', callName: '^my_test_function', includeAliases: true }
+            ], { showCode: false }));
+        })()}
+		`;
+    }
+});
+(0, doc_query_1.registerQueryDocumentation)('compound', {
+    name: 'Compound Query',
+    type: 'virtual',
+    shortDescription: 'Combines multiple queries of the same type into one, specifying common arguments.',
+    functionName: compound_query_1.executeCompoundQueries.name,
+    functionFile: '../queries/virtual-query/compound-query.ts',
+    buildExplanation: async (shell) => {
+        return `
+A compound query comes in use, whenever we want to state multiple queries of the same type with a set of common arguments.
+It offers the following properties of interest:
+
+1. **Query** (\`query\`): the type of the query that is to be combined.
+2. **Common Arguments** (\`commonArguments\`): The arguments that are to be used as defaults for all queries (i.e., any argument the query may have).
+3. **Arguments** (\`arguments\`): The other arguments for the individual queries that are to be combined.
+
+For example, consider the following compound query that combines two call-context queries for \`mean\` and \`print\`, both of which are to be
+assigned to the kind \`visualize\` and the subkind \`text\` (using the example code from above):
+
+${await (0, doc_query_1.showQuery)(shell, example_query_code_1.exampleQueryCode, [{
+                type: 'compound',
+                query: 'call-context',
+                commonArguments: { kind: 'visualize', subkind: 'text' },
+                arguments: [
+                    { callName: '^mean$' },
+                    { callName: '^print$' }
+                ]
+            }], { showCode: false })}
+
+Of course, in this specific scenario, the following query would be equivalent:
+
+${await (0, doc_query_1.showQuery)(shell, example_query_code_1.exampleQueryCode, [
+            { type: 'call-context', callName: '^(mean|print)$', kind: 'visualize', subkind: 'text' }
+        ], { showCode: false, collapseResult: true })}
+
+However, compound queries become more useful whenever common arguments can not be expressed as a union in one of their properties.
+Additionally, you can still overwrite default arguments. 
+In the following, we (by default) want all calls to not resolve to a local definition, except for those to \`print\` for which we explicitly
+want to resolve to a local definition:
+
+${await (0, doc_query_1.showQuery)(shell, example_query_code_1.exampleQueryCode, [{
+                type: 'compound',
+                query: 'call-context',
+                commonArguments: { kind: 'visualize', subkind: 'text', callTargets: call_context_query_format_1.CallTargets.OnlyGlobal },
+                arguments: [
+                    { callName: '^mean$' },
+                    { callName: '^print$', callTargets: call_context_query_format_1.CallTargets.OnlyLocal }
+                ]
+            }], { showCode: false })}
+
+Now, the results no longer contain calls to \`plot\` that are not defined locally. 
+
+		`;
+    }
+});
+async function getText(shell) {
+    const rversion = (await shell.usedRVersion())?.format() ?? 'unknown';
+    return `${(0, doc_auto_gen_1.autoGenHeader)({ filename: module.filename, purpose: 'query API', rVersion: rversion })}
+
+This page briefly summarizes flowR's query API, represented by the ${query_1.executeQueries.name} function in ${(0, doc_files_1.getFilePathMd)('../queries/query.ts')}.
+Please see the [Interface](${doc_files_1.FlowrWikiBaseRef}/Interface) wiki page for more information on how to access this API.
+
+First, consider that you have a file like the following (of course, this is just a simple and artificial example):
+
+\`\`\`r
+${example_query_code_1.exampleQueryCode}
+\`\`\`
+
+<details> <summary>Dataflow Graph of the Example</summary>
+
+${await (0, doc_dfg_1.printDfGraphForCode)(shell, example_query_code_1.exampleQueryCode, { showCode: false })}
+
+</details>
+
+&nbsp;
+
+Additionally, consider that you are interested in all function calls which loads data with \`read_csv\`.
+A simple \`regex\`-based query could look like this: \`^read_csv$\`.
+However, this fails to incorporate
+ 
+1. Syntax-based information (comments, strings, used as a variable, called as a higher-order function, ...)
+2. Semantic information (e.g., \`read_csv\` is overwritten by a function with the same name)
+3. Context information (e.g., calls like \`points\` may link to the current plot)
+
+To solve this, flowR provides a query API which allows you to specify queries on the dataflow graph.
+For the specific use-case stated, you could use the [Call-Context Query](#call-context-query) to find all calls to \`read_csv\` which refer functions that are not overwritten.
+
+Just as an example, the following [Call-Context Query](#call-context-query) finds all calls to \`read_csv\` that are not overwritten:
+
+${await (0, doc_query_1.showQuery)(shell, example_query_code_1.exampleQueryCode, [{ type: 'call-context', callName: '^read_csv$', callTargets: call_context_query_format_1.CallTargets.OnlyGlobal, kind: 'input', subkind: 'csv-file' }], { showCode: false })}
+
+## The Query Format
+
+Queries are JSON arrays of query objects, each of which uses a \`type\` property to specify the query type.
+In general, we separate two types of queries:
+
+1. **Active Queries**: Are exactly what you would expect from a query (e.g., the [Call-Context Query](#call-context-query)). They fetch information from the dataflow graph.
+2. **Virtual Queries**: Are used to structure your queries (e.g., the [Compound Query](#compound-query)). 
+
+We separate these from a concept perspective. 
+For now, we support the following **active** queries (which we will refer to simply as a \`query\`):
+
+${(0, doc_query_1.tocForQueryType)('active')}
+
+Similarly, we support the following **virtual** queries: 
+
+${(0, doc_query_1.tocForQueryType)('virtual')}
+
+<details>
+
+
+<summary>Detailed Query Format (Automatically Generated)</summary>
+
+Although it is probably better to consult the detailed explanations below, if you want to have a look at the scehma, here is its description:
+
+${(0, schema_1.describeSchema)(query_schema_1.QueriesSchema, ansi_1.markdownFormatter)}
+
+</details>
+
+${await (0, doc_query_1.explainQueries)(shell, 'active')}
+
+${await (0, doc_query_1.explainQueries)(shell, 'virtual')}
+
+`;
+}
+/** if we run this script, we want a Markdown representation of the capabilities */
+if (require.main === module) {
+    (0, log_1.setMinLevelOfAllLogs)(6 /* LogLevel.Fatal */);
+    const shell = new shell_1.RShell();
+    void getText(shell).then(str => {
+        console.log(str);
+    }).finally(() => {
+        shell.close();
+    });
+}
+//# sourceMappingURL=print-query-wiki.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/flowr",
-  "version": "2.0.25",
+  "version": "2.1.0",
   "description": "Static Dataflow Analyzer and Program Slicer for the R Programming Language",
   "types": "dist/src/index.d.ts",
   "repository": {
@@ -24,7 +24,11 @@
     "benchmark": "npm run build && node dist/src/cli/benchmark-app.js",
     "summarizer": "ts-node src/cli/summarizer-app.ts",
     "export-quads": "ts-node src/cli/export-quads-app.ts",
-    "capabilities-markdown": "ts-node src/r-bridge/data/print.ts",
+    "capabilities-markdown": "ts-node src/documentation/print-capabilities-markdown.ts",
+    "wiki:df-graph": "ts-node src/documentation/print-dataflow-graph-wiki.ts",
+    "wiki:normalized-ast": "ts-node src/documentation/print-normalized-ast-wiki.ts",
+    "wiki:query-api": "ts-node src/documentation/print-query-wiki.ts",
+    "wiki:interface": "ts-node src/documentation/print-interface-wiki.ts",
     "build": "tsc --project .",
     "build:bundle-flowr": "npm run build && esbuild --bundle dist/src/cli/flowr.js --platform=node --bundle --minify --target=node18 --outfile=dist/src/cli/flowr.min.js",
     "lint-local": "npx eslint --version && npx eslint src/ test/ --rule \"no-warning-comments: off\"",
@@ -185,11 +189,8 @@
   "devDependencies": {
     "@commitlint/cli": "^19.3.0",
     "@commitlint/config-angular": "^19.3.0",
-    "@eagleoutice/eslint-config-flowr": "^1.0.11",
+    "@eagleoutice/eslint-config-flowr": "^1.0.14",
     "@j-ulrich/release-it-regex-bumper": "^5.1.0",
-    "@stylistic/eslint-plugin": "^2.1.0",
-    "@stylistic/eslint-plugin-plus": "^2.1.0",
-    "@stylistic/eslint-plugin-ts": "^2.1.0",
     "@types/chai": "^4.3.16",
     "@types/chai-as-promised": "^7.1.8",
     "@types/command-line-args": "^5.2.3",
@@ -204,41 +205,36 @@
     "@typescript-eslint/eslint-plugin": "^7.8.0",
     "chai": "^4.3.16",
     "chai-as-promised": "^7.1.1",
-    "esbuild": "0.21.3",
-    "eslint": "^8.57.0",
-    "eslint-plugin-check-file": "^2.8.0",
-    "eslint-plugin-import": "^2.29.1",
-    "eslint-plugin-n": "^17.6.0",
-    "eslint-plugin-promise": "^6.1.1",
-    "eslint-plugin-tsdoc": "^0.2.17",
+    "esbuild": "^0.23.1",
+    "eslint": "^8.57.1",
     "license-checker": "^25.0.1",
-    "mocha": "^10.2.0",
+    "mocha": "^10.7.3",
     "mocha-multi-reporters": "^1.5.1",
-    "nyc": "^15.1.0",
-    "release-it": "^17.0.1",
+    "nyc": "^17.0.0",
+    "release-it": "^17.6.0",
     "ts-node": "^10.9.2",
-    "typedoc": "^0.25.13",
-    "typedoc-plugin-missing-exports": "^2.2.0",
-    "typedoc-theme-hierarchy": "^4.1.2",
-    "typedoc-umlclass": "^0.9.0",
-    "typescript": "^5.3.3"
+    "typedoc": "^0.26.7",
+    "typedoc-plugin-missing-exports": "^3.0.0",
+    "typedoc-theme-hierarchy": "^5.0.3",
+    "typedoc-umlclass": "^0.10.0",
+    "typescript": "^5.6.2"
   },
   "dependencies": {
-    "@xmldom/xmldom": "^0.8.10",
-    "command-line-args": "^5.2.1",
-    "command-line-usage": "^7.0.1",
-    "joi": "^17.13.1",
+    "@xmldom/xmldom": "^0.9.2",
+    "command-line-args": "^6.0.0",
+    "command-line-usage": "^7.0.3",
+    "joi": "^17.13.3",
     "n-readlines": "^1.0.1",
-    "n3": "^1.17.2",
+    "n3": "^1.21.3",
     "object-hash": "^3.0.0",
-    "object-sizeof": "^2.6.4",
-    "rotating-file-stream": "^3.1.1",
-    "semver": "^7.5.4",
-    "tar": "^7.1.0",
+    "object-sizeof": "^2.6.5",
+    "rotating-file-stream": "^3.2.5",
+    "semver": "^7.6.3",
+    "tar": "^7.4.3",
     "tmp": "^0.2.3",
-    "ts-essentials": "^9.4.1",
-    "tslog": "^4.9.2",
-    "ws": "^8.17.0",
+    "ts-essentials": "^10.0.2",
+    "tslog": "^4.9.3",
+    "ws": "^8.18.0",
     "xpath-ts2": "^1.4.2"
   }
 }

package/queries/base-query-format.d.ts

@@ -0,0 +1,11 @@
+export interface BaseQueryFormat {
+    /** used to select the query type :) */
+    readonly type: string;
+}
+export interface BaseQueryMeta {
+    /** Duration in milliseconds */
+    readonly timing: number;
+}
+export interface BaseQueryResult {
+    readonly '.meta': BaseQueryMeta;
+}

package/{cli/repl/server/messages/hello.js → queries/base-query-format.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=hello.js.map
+//# sourceMappingURL=base-query-format.js.map

package/queries/call-context-query/call-context-query-executor.d.ts

@@ -0,0 +1,11 @@
+import type { CallContextQuery, CallContextQueryResult } from './call-context-query-format';
+import type { BasicQueryData } from '../query';
+/**
+ * Multi-stage call context query resolve.
+ *
+ * 1. Resolve all calls in the DF graph that match the respective {@link DefaultCallContextQueryFormat#callName} regex.
+ * 2. Identify their respective call targets, if {@link DefaultCallContextQueryFormat#callTargets} is set to be non-any.
+ *    This happens during the main resolution!
+ * 3. Attach `linkTo` calls to the respective calls.
+ */
+export declare function executeCallContextQueries({ graph, ast }: BasicQueryData, queries: readonly CallContextQuery[]): CallContextQueryResult;

package/queries/call-context-query/call-context-query-executor.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeCallContextQueries = executeCallContextQueries;
+const call_context_query_format_1 = require("./call-context-query-format");
+const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
+const vertex_1 = require("../../dataflow/graph/vertex");
+const assert_1 = require("../../util/assert");
+const edge_1 = require("../../dataflow/graph/edge");
+const resolve_by_name_1 = require("../../dataflow/environments/resolve-by-name");
+const built_in_1 = require("../../dataflow/environments/built-in");
+const cfg_1 = require("../../util/cfg/cfg");
+const two_layer_collector_1 = require("../two-layer-collector");
+const objects_1 = require("../../util/objects");
+const visitor_1 = require("../../util/cfg/visitor");
+const identifier_1 = require("../../dataflow/environments/identifier");
+function satisfiesCallTargets(id, graph, callTarget) {
+    const callVertex = graph.get(id);
+    if (callVertex === undefined || callVertex[0].tag !== vertex_1.VertexType.FunctionCall) {
+        return 'no';
+    }
+    const [info, outgoing] = callVertex;
+    const callTargets = [...outgoing]
+        .filter(([, e]) => (0, edge_1.edgeIncludesType)(e.types, edge_1.EdgeType.Calls))
+        .map(([t]) => t);
+    let builtIn = false;
+    if (info.environment === undefined) {
+        /* if we have a call with an unbound environment,
+         * this only happens if we are sure of built-in relations and want to save references
+         */
+        builtIn = true;
+    }
+    else {
+        /*
+         * for performance and scoping reasons, flowR will not identify the global linkage,
+         * including any potential built-in mapping.
+         */
+        const reResolved = (0, resolve_by_name_1.resolveByName)(info.name, info.environment, identifier_1.ReferenceType.Unknown);
+        if (reResolved && reResolved.some(t => t.definedAt === built_in_1.BuiltIn)) {
+            builtIn = true;
+        }
+    }
+    switch (callTarget) {
+        case call_context_query_format_1.CallTargets.Any:
+            return callTargets;
+        case call_context_query_format_1.CallTargets.OnlyGlobal:
+            if (callTargets.length === 0) {
+                return builtIn ? [built_in_1.BuiltIn] : [];
+            }
+            else {
+                return 'no';
+            }
+        case call_context_query_format_1.CallTargets.MustIncludeGlobal:
+            return builtIn || callTargets.length === 0 ? [...callTargets, built_in_1.BuiltIn] : 'no';
+        case call_context_query_format_1.CallTargets.OnlyLocal:
+            return !builtIn && callTargets.length > 0 ? callTargets : 'no';
+        case call_context_query_format_1.CallTargets.MustIncludeLocal:
+            if (callTargets.length > 0) {
+                return builtIn ? [...callTargets, built_in_1.BuiltIn] : callTargets;
+            }
+            else {
+                return 'no';
+            }
+        default:
+            (0, assert_1.assertUnreachable)(callTarget);
+    }
+}
+/* if the node is effected by nse, we have an ingoing nse edge */
+function isQuoted(node, graph) {
+    const vertex = graph.ingoingEdges(node);
+    if (vertex === undefined) {
+        return false;
+    }
+    return [...vertex.values()].some(({ types }) => (0, edge_1.edgeIncludesType)(types, edge_1.EdgeType.NonStandardEvaluation));
+}
+function makeReport(collector) {
+    const result = {};
+    for (const [kind, collected] of collector.store) {
+        const subkinds = {};
+        for (const [subkind, values] of collected) {
+            subkinds[subkind] ??= [];
+            const collectIn = subkinds[subkind];
+            for (const value of values) {
+                collectIn.push(value);
+            }
+        }
+        result[kind] = {
+            subkinds
+        };
+    }
+    return result;
+}
+function isSubCallQuery(query) {
+    return 'linkTo' in query;
+}
+function promoteQueryCallNames(queries) {
+    let requiresCfg = false;
+    const promotedQueries = queries.map(q => {
+        if (isSubCallQuery(q)) {
+            requiresCfg = true;
+            return {
+                ...q,
+                callName: new RegExp(q.callName),
+                linkTo: {
+                    ...q.linkTo,
+                    /* we have to add another promotion layer whenever we add something without this call name */
+                    callName: new RegExp(q.linkTo.callName)
+                }
+            };
+        }
+        else {
+            return {
+                ...q,
+                callName: new RegExp(q.callName)
+            };
+        }
+    });
+    return { promotedQueries, requiresCfg };
+}
+function identifyLinkToLastCallRelation(from, cfg, graph, linkTo) {
+    const found = [];
+    (0, visitor_1.visitInReverseOrder)(cfg, from, node => {
+        /* we ignore the start id as it cannot be the last call */
+        if (node === from) {
+            return;
+        }
+        const vertex = graph.getVertex(node);
+        if (vertex === undefined || vertex.tag !== vertex_1.VertexType.FunctionCall) {
+            return;
+        }
+        if (linkTo.test(vertex.name)) {
+            found.push(node);
+            return true;
+        }
+    });
+    return found;
+}
+/* maybe we want to add caches to this */
+function retrieveAllCallAliases(nodeId, graph) {
+    /* we want the names of all functions called at the source id, including synonyms and returns */
+    const aliases = new Map();
+    const visited = new Set();
+    /* we store the current call name */
+    const queue = [[(0, node_id_1.recoverContent)(nodeId, graph) ?? '', nodeId]];
+    while (queue.length > 0) {
+        const [str, id] = queue.shift();
+        if (visited.has(id)) {
+            continue;
+        }
+        visited.add(id);
+        if (id !== nodeId) {
+            const present = aliases.get(str);
+            if (present) {
+                present.push(id);
+            }
+            else {
+                aliases.set(str, [id]);
+            }
+        }
+        const vertex = graph.get(id);
+        if (vertex === undefined) {
+            continue;
+        }
+        const [info, outgoing] = vertex;
+        if (info.tag !== vertex_1.VertexType.FunctionCall) {
+            const x = [...outgoing]
+                .filter(([, { types }]) => (0, edge_1.edgeIncludesType)(types, edge_1.EdgeType.Reads | edge_1.EdgeType.DefinedBy | edge_1.EdgeType.DefinedByOnCall))
+                .map(([t]) => [(0, node_id_1.recoverContent)(t, graph) ?? '', t]);
+            /** only follow defined-by and reads */
+            queue.push(...x);
+            continue;
+        }
+        let track = edge_1.EdgeType.Calls | edge_1.EdgeType.Reads | edge_1.EdgeType.DefinedBy | edge_1.EdgeType.DefinedByOnCall;
+        if (id !== nodeId) {
+            track |= edge_1.EdgeType.Returns;
+        }
+        const out = [...outgoing]
+            .filter(([, e]) => (0, edge_1.edgeIncludesType)(e.types, track) && (nodeId !== id || !(0, edge_1.edgeIncludesType)(e.types, edge_1.EdgeType.Argument)))
+            .map(([t]) => t);
+        for (const call of out) {
+            queue.push([(0, node_id_1.recoverContent)(call, graph) ?? (0, node_id_1.recoverContent)(id, graph) ?? '', call]);
+        }
+    }
+    return aliases;
+}
+/**
+ * Multi-stage call context query resolve.
+ *
+ * 1. Resolve all calls in the DF graph that match the respective {@link DefaultCallContextQueryFormat#callName} regex.
+ * 2. Identify their respective call targets, if {@link DefaultCallContextQueryFormat#callTargets} is set to be non-any.
+ *    This happens during the main resolution!
+ * 3. Attach `linkTo` calls to the respective calls.
+ */
+function executeCallContextQueries({ graph, ast }, queries) {
+    /* omit performance page load */
+    const now = Date.now();
+    /* the node id and call targets if present */
+    const initialIdCollector = new two_layer_collector_1.TwoLayerCollector();
+    /* promote all strings to regex patterns */
+    const { promotedQueries, requiresCfg } = promoteQueryCallNames(queries);
+    let cfg = undefined;
+    if (requiresCfg) {
+        cfg = (0, cfg_1.extractCFG)(ast);
+    }
+    const queriesWhichWantAliases = promotedQueries.filter(q => q.includeAliases);
+    for (const [nodeId, info] of graph.vertices(true)) {
+        if (info.tag !== vertex_1.VertexType.FunctionCall) {
+            continue;
+        }
+        /* if we have a vertex, and we check for aliased calls, we want to know if we define this as desired! */
+        if (queriesWhichWantAliases.length > 0) {
+            /*
+             * yes, we make an expensive call target check, we can probably do a lot of optimization here, e.g.,
+             * by checking all of these queries would be satisfied otherwise,
+             * in general, we first want a call to happen, i.e., trace the called targets of this!
+             */
+            const targets = retrieveAllCallAliases(nodeId, graph);
+            for (const [l, ids] of targets.entries()) {
+                for (const query of queriesWhichWantAliases) {
+                    if (query.callName.test(l)) {
+                        initialIdCollector.add(query.kind ?? '.', query.subkind ?? '.', (0, objects_1.compactRecord)({ id: nodeId, aliasRoots: ids }));
+                    }
+                }
+            }
+        }
+        for (const query of promotedQueries.filter(q => q.callName.test(info.name))) {
+            let targets = undefined;
+            if (query.callTargets) {
+                targets = satisfiesCallTargets(nodeId, graph, query.callTargets);
+                if (targets === 'no') {
+                    continue;
+                }
+            }
+            if (isQuoted(nodeId, graph)) {
+                /* if the call is quoted, we do not want to link to it */
+                continue;
+            }
+            let linkedIds = undefined;
+            if (cfg && isSubCallQuery(query)) {
+                /* if we have a linkTo query, we have to find the last call */
+                const lastCall = identifyLinkToLastCallRelation(nodeId, cfg.graph, graph, query.linkTo.callName);
+                if (lastCall) {
+                    linkedIds = lastCall;
+                }
+            }
+            initialIdCollector.add(query.kind ?? '.', query.subkind ?? '.', (0, objects_1.compactRecord)({ id: nodeId, calls: targets, linkedIds }));
+        }
+    }
+    return {
+        '.meta': {
+            timing: Date.now() - now,
+        },
+        kinds: makeReport(initialIdCollector)
+    };
+}
+//# sourceMappingURL=call-context-query-executor.js.map