@eagleoutice/flowr 2.4.6 → 2.4.8

package/linter/linter-executor.js

@@ -5,22 +5,30 @@ const linter_rules_1 = require("./linter-rules");
 const flowr_search_executor_1 = require("../search/flowr-search-executor");
 const objects_1 = require("../util/objects");
 function executeLintingRule(ruleName, input, lintingRuleConfig) {
-    const rule = linter_rules_1.LintingRules[ruleName];
-    const fullConfig = (0, objects_1.deepMergeObject)(rule.info.defaultConfig, lintingRuleConfig);
-    const ruleSearch = rule.createSearch(fullConfig, input);
-    const searchStart = Date.now();
-    const searchResult = (0, flowr_search_executor_1.runSearch)(ruleSearch, input);
-    const searchTime = Date.now() - searchStart;
-    const processStart = Date.now();
-    const result = rule.processSearchResult(searchResult, fullConfig, input);
-    const processTime = Date.now() - processStart;
-    return {
-        ...result,
-        '.meta': {
-            ...result['.meta'],
-            searchTimeMs: searchTime,
-            processTimeMs: processTime
-        }
-    };
+    try {
+        const rule = linter_rules_1.LintingRules[ruleName];
+        const fullConfig = (0, objects_1.deepMergeObject)(rule.info.defaultConfig, lintingRuleConfig);
+        const ruleSearch = rule.createSearch(fullConfig, input);
+        const searchStart = Date.now();
+        const searchResult = (0, flowr_search_executor_1.runSearch)(ruleSearch, input);
+        const searchTime = Date.now() - searchStart;
+        const processStart = Date.now();
+        const result = rule.processSearchResult(searchResult, fullConfig, input);
+        const processTime = Date.now() - processStart;
+        return {
+            ...result,
+            '.meta': {
+                ...result['.meta'],
+                searchTimeMs: searchTime,
+                processTimeMs: processTime
+            }
+        };
+    }
+    catch (e) {
+        const msg = typeof e === 'string' ? e : e instanceof Error ? e.message : JSON.stringify(e);
+        return {
+            error: msg
+        };
+    }
 }
 //# sourceMappingURL=linter-executor.js.map

package/linter/linter-format.d.ts

@@ -105,13 +105,22 @@ export interface ConfiguredLintingRule<Name extends LintingRuleNames = LintingRu
     readonly name: Name;
     readonly config: DeepPartial<LintingRuleConfig<Name>>;
 }
-export interface LintingResults<Name extends LintingRuleNames> {
+/**
+ * For when a linting rule throws an error during execution
+ */
+export interface LintingResultsError {
+    readonly error: string;
+}
+export interface LintingResultsSuccess<Name extends LintingRuleNames> {
     results: LintingRuleResult<Name>[];
     '.meta': LintingRuleMetadata<Name> & {
         readonly searchTimeMs: number;
         readonly processTimeMs: number;
     };
 }
+export declare function isLintingResultsError<Name extends LintingRuleNames>(o: LintingResults<Name>): o is LintingResultsError;
+export declare function isLintingResultsSuccess<Name extends LintingRuleNames>(o: LintingResults<Name>): o is LintingResultsSuccess<Name>;
+export type LintingResults<Name extends LintingRuleNames> = LintingResultsSuccess<Name> | LintingResultsError;
 export declare enum LintingResultCertainty {
     /**
      * The linting rule cannot say for sure whether the result is correct or not.

package/linter/linter-format.js

@@ -1,6 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LintingPrettyPrintContext = exports.LintingRuleCertainty = exports.LintingResultCertainty = void 0;
+exports.isLintingResultsError = isLintingResultsError;
+exports.isLintingResultsSuccess = isLintingResultsSuccess;
+function isLintingResultsError(o) {
+    return 'error' in o;
+}
+function isLintingResultsSuccess(o) {
+    return 'results' in o;
+}
 var LintingResultCertainty;
 (function (LintingResultCertainty) {
     /**

package/linter/linter-rules.d.ts

@@ -173,6 +173,7 @@ export declare const LintingRules: {
             readonly tags: readonly [import("./linter-tags").LintingRuleTag.Style, import("./linter-tags").LintingRuleTag.QuickFix];
             readonly defaultConfig: {
                 readonly caseing: "auto";
+                readonly ignoreNonAlpha: true;
             };
         };
     };

package/linter/rules/absolute-path.js

@@ -52,8 +52,7 @@ const PathFunctions = {
     'file.path': (df, vtx, config) => {
         const fsep = (0, resolve_argument_1.getArgumentStringValue)(config.solver.variables, df, vtx, undefined, 'fsep', true);
         // in the future we can access `.Platform$file.sep` here
-        const v = fsep?.values();
-        const sepValues = v ? [...v].flatMap(s => [...s].filter(assert_1.isNotUndefined)) : [path_1.default.sep];
+        const sepValues = new Array(...fsep?.values()?.flatMap(s => [...s].filter(assert_1.isNotUndefined)) ?? [path_1.default.sep]);
         if (sepValues.some(s => s === dependencies_query_format_1.Unknown || (0, assert_1.isUndefined)(s))) {
             // if we have no fsep, we cannot construct a path
             return undefined;
@@ -119,19 +118,19 @@ exports.ABSOLUTE_PATH = {
                 }
                 else if ((0, search_enrichers_1.enrichmentContent)(element, search_enrichers_1.Enrichment.QueryData)) {
                     const result = queryResults[(0, search_enrichers_1.enrichmentContent)(element, search_enrichers_1.Enrichment.QueryData).query];
-                    const mappedStrings = result.readData.filter(r => r.source !== dependencies_query_format_1.Unknown && (0, strings_1.isAbsolutePath)(r.source, regex)).map(r => {
+                    const mappedStrings = result.read.filter(r => r.value !== undefined && r.value !== dependencies_query_format_1.Unknown && (0, strings_1.isAbsolutePath)(r.value, regex)).map(r => {
                         const elem = data.normalize.idMap.get(r.nodeId);
                         return {
                             certainty: linter_format_1.LintingResultCertainty.Certain,
-                            filePath: r.source,
+                            filePath: r.value,
                             range: elem?.info.fullRange ?? elem?.location ?? (0, range_1.rangeFrom)(-1, -1, -1, -1),
-                            quickFix: buildQuickFix(elem, r.source, wd)
+                            quickFix: buildQuickFix(elem, r.value, wd)
                         };
                     });
                     if (mappedStrings.length > 0) {
                         return mappedStrings;
                     }
-                    else if (result.readData.every(r => r.source !== dependencies_query_format_1.Unknown)) {
+                    else if (result.read.every(r => r.value !== dependencies_query_format_1.Unknown)) {
                         // if we have no absolute paths, but all paths are known, we can return an empty array
                         return [];
                     }
@@ -145,7 +144,8 @@ exports.ABSOLUTE_PATH = {
                             return strings.filter(s => (0, strings_1.isAbsolutePath)(s, regex)).map(str => ({
                                 certainty: linter_format_1.LintingResultCertainty.Uncertain,
                                 filePath: str,
-                                range: node.info.fullRange ?? node.location ?? (0, range_1.rangeFrom)(-1, -1, -1, -1)
+                                range: node.info.fullRange ?? node.location ?? (0, range_1.rangeFrom)(-1, -1, -1, -1),
+                                quickFix: undefined
                             }));
                         }
                     }
@@ -159,7 +159,7 @@ exports.ABSOLUTE_PATH = {
     },
     prettyPrint: {
         [linter_format_1.LintingPrettyPrintContext.Query]: result => `Path \`${result.filePath}\` at ${(0, dfg_1.formatRange)(result.range)}`,
-        [linter_format_1.LintingPrettyPrintContext.Full]: result => `Path \`${result.filePath}\` at ${(0, dfg_1.formatRange)(result.range)} is not absolute`
+        [linter_format_1.LintingPrettyPrintContext.Full]: result => `Path \`${result.filePath}\` at ${(0, dfg_1.formatRange)(result.range)} is absolute`
     },
     info: {
         name: 'Absolute Paths',

package/linter/rules/dataframe-access-validation.js

@@ -42,7 +42,7 @@ exports.DATA_FRAME_ACCESS_VALIDATION = {
             }
             accesses.push(access);
         }
-        const operations = [...accessOperations.entries()].flatMap(([, operations]) => operations);
+        const operations = accessOperations.entries().flatMap(([, operations]) => operations).toArray();
         const metadata = {
             numOperations: accessOperations.size,
             numAccesses: operations.length,

package/linter/rules/file-path-validity.js

@@ -8,18 +8,15 @@ const dependencies_query_format_1 = require("../../queries/catalog/dependencies-
 const built_in_source_1 = require("../../dataflow/internal/process/functions/call/built-in/built-in-source");
 const logic_1 = require("../../util/logic");
 const retriever_1 = require("../../r-bridge/retriever");
-const read_functions_1 = require("../../queries/catalog/dependencies-query/function-info/read-functions");
-const write_functions_1 = require("../../queries/catalog/dependencies-query/function-info/write-functions");
 const happens_before_1 = require("../../control-flow/happens-before");
 const linter_tags_1 = require("../linter-tags");
 const search_enrichers_1 = require("../../search/search-executor/search-enrichers");
 exports.FILE_PATH_VALIDITY = {
     createSearch: (config) => flowr_search_builder_1.Q.fromQuery({
         type: 'dependencies',
-        // we only want to check read and write functions, so we explicitly clear all others
-        ignoreDefaultFunctions: true,
-        readFunctions: read_functions_1.ReadFunctions.concat(config.additionalReadFunctions),
-        writeFunctions: write_functions_1.WriteFunctions.concat(config.additionalWriteFunctions)
+        enabledCategories: ['read', 'write'],
+        readFunctions: config.additionalReadFunctions,
+        writeFunctions: config.additionalWriteFunctions
     }).with(search_enrichers_1.Enrichment.CfgInformation),
     processSearchResult: (elements, config, data) => {
         const cfg = elements.enrichmentContent(search_enrichers_1.Enrichment.CfgInformation).cfg.graph;
@@ -32,14 +29,14 @@ exports.FILE_PATH_VALIDITY = {
         return {
             results: elements.getElements().flatMap(element => {
                 const results = elements.enrichmentContent(search_enrichers_1.Enrichment.QueryData).queries['dependencies'];
-                const matchingRead = results.readData.find(r => r.nodeId == element.node.info.id);
+                const matchingRead = results.read.find(r => r.nodeId == element.node.info.id);
                 if (!matchingRead) {
                     return [];
                 }
                 metadata.totalReads++;
                 const range = element.node.info.fullRange;
                 // check if we can't parse the file path statically
-                if (matchingRead.source === dependencies_query_format_1.Unknown) {
+                if (matchingRead.value === dependencies_query_format_1.Unknown) {
                     metadata.totalUnknown++;
                     if (config.includeUnknown) {
                         return [{
@@ -53,14 +50,14 @@ exports.FILE_PATH_VALIDITY = {
                     }
                 }
                 // check if any write to the same file happens before the read, and exclude this case if so
-                const writesToFile = results.writtenData.filter(r => samePath(r.destination, matchingRead.source, data.config.solver.resolveSource?.ignoreCapitalization));
+                const writesToFile = results.write.filter(r => samePath(r.value, matchingRead.value, data.config.solver.resolveSource?.ignoreCapitalization));
                 const writesBefore = writesToFile.map(w => (0, happens_before_1.happensBefore)(cfg, w.nodeId, element.node.info.id));
                 if (writesBefore.some(w => w === logic_1.Ternary.Always)) {
                     metadata.totalWritesBeforeAlways++;
                     return [];
                 }
                 // check if the file exists!
-                const paths = (0, built_in_source_1.findSource)(data.config.solver.resolveSource, matchingRead.source, {
+                const paths = (0, built_in_source_1.findSource)(data.config.solver.resolveSource, matchingRead.value, {
                     referenceChain: element.node.info.file ? [(0, retriever_1.requestFromInput)(`file://${element.node.info.file}`)] : []
                 });
                 if (paths && paths.length) {
@@ -69,7 +66,7 @@ exports.FILE_PATH_VALIDITY = {
                 }
                 return [{
                         range,
-                        filePath: matchingRead.source,
+                        filePath: matchingRead.value,
                         certainty: writesBefore && writesBefore.length && writesBefore.every(w => w === logic_1.Ternary.Maybe) ? linter_format_1.LintingResultCertainty.Uncertain : linter_format_1.LintingResultCertainty.Certain
                     }];
             }),

package/linter/rules/naming-convention.d.ts

@@ -23,7 +23,10 @@ export interface NamingConventionResult extends LintingResult {
  * It is planned to have a config like ESLint
  */
 export interface NamingConventionConfig extends MergeableRecord {
+    /** which casing convention to enforce */
     caseing: CasingConvention | 'auto';
+    /** if true non alphabetic characters are ignored */
+    ignoreNonAlpha: boolean;
 }
 export interface NamingConventionMetadata extends MergeableRecord {
     /** number of symbols matching the casing convetion */
@@ -35,7 +38,7 @@ export declare function detectCasing(identifier: string): CasingConvention;
 export declare function getMostUsedCasing(symbols: {
     detectedCasing: CasingConvention;
 }[]): CasingConvention;
-export declare function fixCasing(identifier: string, convention: CasingConvention): string;
+export declare function fixCasing(identifier: string, convention: CasingConvention): string | undefined;
 export declare function createNamingConventionQuickFixes(graph: DataflowGraph, nodeId: NodeId, replacement: string, conv: CasingConvention): LintQuickFixReplacement[] | undefined;
 export declare const NAMING_CONVENTION: {
     readonly createSearch: (_config: NamingConventionConfig) => import("../../search/flowr-search-builder").FlowrSearchBuilder<"all", ["filter"], import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../search/flowr-search").FlowrSearchElements<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, [] | import("../../search/flowr-search").FlowrSearchElement<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>>;
@@ -67,6 +70,7 @@ export declare const NAMING_CONVENTION: {
         readonly tags: readonly [LintingRuleTag.Style, LintingRuleTag.QuickFix];
         readonly defaultConfig: {
             readonly caseing: "auto";
+            readonly ignoreNonAlpha: true;
         };
     };
 };

package/linter/rules/naming-convention.js

@@ -22,8 +22,11 @@ var CasingConvention;
     CasingConvention["PascalSnakeCase"] = "Pascal_Snake_Case";
     CasingConvention["Unknown"] = "unknown";
 })(CasingConvention || (exports.CasingConvention = CasingConvention = {}));
+function containsAlpha(s) {
+    return /[A-Za-z]/.test(s);
+}
 function detectCasing(identifier) {
-    if (identifier.trim() === '') {
+    if (identifier.trim() === '' || !containsAlpha(identifier)) {
         return CasingConvention.Unknown;
     }
     const upper = identifier.toUpperCase();
@@ -78,8 +81,16 @@ function getMostUsedCasing(symbols) {
     return [...map].reduce((p, c) => p[1] > c[1] ? p : c)[0];
 }
 function fixCasing(identifier, convention) {
+    if (!containsAlpha(identifier)) {
+        return undefined;
+    }
     const tokens = identifier.split(/(?=[A-Z])|_/).map(s => s.toLowerCase());
-    const firstUp = (s) => `${s[0].toUpperCase()}${s.substring(1)}`;
+    const firstUp = (s) => {
+        if (s.length < 1) {
+            return s.toUpperCase();
+        }
+        return `${s[0].toUpperCase()}${s.substring(1)}`;
+    };
     switch (convention) {
         case CasingConvention.CamelCase: // camelCase
             return `${tokens[0]}${tokens.slice(1).map(firstUp).join('')}`;
@@ -139,11 +150,15 @@ exports.NAMING_CONVENTION = {
             id: m.node.info.id
         }));
         const casing = config.caseing === 'auto' ? getMostUsedCasing(symbols) : config.caseing;
-        const results = symbols.filter(m => m.detectedCasing !== casing)
-            .map(({ id, ...m }) => ({
-            ...m,
-            quickFix: createNamingConventionQuickFixes(data.dataflow.graph, id, fixCasing(m.name, casing), casing)
-        }));
+        const results = symbols
+            .filter(m => (m.detectedCasing !== casing) && (!config.ignoreNonAlpha || containsAlpha(m.name)))
+            .map(({ id, ...m }) => {
+            const fix = fixCasing(m.name, casing);
+            return {
+                ...m,
+                quickFix: fix ? createNamingConventionQuickFixes(data.dataflow.graph, id, fix, casing) : undefined
+            };
+        });
         return {
             results: results,
             '.meta': {
@@ -163,7 +178,8 @@ exports.NAMING_CONVENTION = {
         description: 'Checks wether the symbols conform to a certain naming convention',
         tags: [linter_tags_1.LintingRuleTag.Style, linter_tags_1.LintingRuleTag.QuickFix],
         defaultConfig: {
-            caseing: 'auto'
+            caseing: 'auto',
+            ignoreNonAlpha: true
         }
     }
 };

package/linter/rules/seeded-randomness.js

@@ -27,8 +27,8 @@ exports.SEEDED_RANDOMNESS = {
         }
     })
         .with(search_enrichers_1.Enrichment.LastCall, [
-        ...config.randomnessProducers.filter(p => p.type === 'function').map(p => ({ callName: p.name })),
-        ...getDefaultAssignments().flatMap(b => b.names).map(a => ({ callName: a, cascadeIf: () => cascade_action_1.CascadeAction.Continue }))
+        { callName: config.randomnessProducers.filter(p => p.type === 'function').map(p => p.name) },
+        { callName: getDefaultAssignments().flatMap(b => b.names), cascadeIf: () => cascade_action_1.CascadeAction.Continue }
     ]),
     processSearchResult: (elements, config, { dataflow }) => {
         const assignmentProducers = new Set(config.randomnessProducers.filter(p => p.type == 'assignment').map(p => p.name));

package/linter/rules/unused-definition.js

@@ -73,7 +73,7 @@ exports.UNUSED_DEFINITION = {
                 }
                 const ingoingEdges = data.dataflow.graph.ingoingEdges(dfgVertex.id);
                 const interestedIn = (0, vertex_1.isVariableDefinitionVertex)(dfgVertex) ? InterestingEdgesVariable : InterestingEdgesFunction;
-                const ingoingInteresting = [...ingoingEdges?.values() ?? []].some(e => (0, edge_1.edgeIncludesType)(e.types, interestedIn));
+                const ingoingInteresting = ingoingEdges?.values().some(e => (0, edge_1.edgeIncludesType)(e.types, interestedIn));
                 if (ingoingInteresting) {
                     return undefined;
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/flowr",
-  "version": "2.4.6",
+  "version": "2.4.8",
   "description": "Static Dataflow Analyzer and Program Slicer for the R Programming Language",
   "types": "dist/src/index.d.ts",
   "repository": {
@@ -15,7 +15,7 @@
     "setup:dev": "git lfs fetch && npm ci && git config --local core.hooksPath .githooks/ && git push --dry-run",
     "main": "npm run build:bundle-flowr && node dist/src/cli/flowr.min.js",
     "flowr": "npm run main --",
-    "main-dev": "ts-node src/cli/flowr.ts",
+    "main-dev": "ts-node-dev src/cli/flowr.ts",
     "publish-library": "cp .npmignore package.json README.md LICENSE dist/src/ && cd dist/src && npm publish --access public",
     "release": "npx release-it --ci",
     "stats": "ts-node src/cli/statistics-app.ts",
@@ -51,8 +51,9 @@
     "test": "vitest --exclude \"test/system-tests/**\" --config test/vitest.config.mts",
     "test:system": "vitest --dir test/system-tests --config test/system-tests/vitest.config.mts",
     "test:coverage": "npm run test -- --coverage",
-    "performance-test": "func() { cd test/performance/ && bash run-all-suites.sh $1 $2 $3 $4; cd ../../; }; func",
+    "test:full": "npm run test-full",
     "test-full": "npm run test:coverage -- --no-watch -- --make-summary --test-installation",
+    "performance-test": "func() { cd test/performance/ && bash run-all-suites.sh $1 $2 $3 $4; cd ../../; }; func",
     "detect-circular-deps": "npx madge  --extensions ts,tsx --circular src/",
     "checkup": "npm run flowr -- --execute \":version\" && npm run lint && npm run test-full -- --allowOnly=false && npm run test:system -- --no-watch && docker build -t test-flowr -f scripts/Dockerfile . && npm run doc && npm run gen:readme && npm-run-all wiki:*"
   },
@@ -177,32 +178,33 @@
     "@commitlint/cli": "^19.7.1",
     "@commitlint/config-angular": "^19.7.1",
     "@eagleoutice/eslint-config-flowr": "^1.0.19",
-    "@eslint/eslintrc": "^3.2.0",
-    "@eslint/js": "^9.20.0",
+    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/js": "^9.34.0",
     "@j-ulrich/release-it-regex-bumper": "^5.3.0",
     "@types/command-line-args": "^5.2.3",
     "@types/command-line-usage": "^5.0.4",
     "@types/n-readlines": "^1.0.6",
-    "@types/n3": "^1.21.1",
+    "@types/n3": "^1.26.0",
     "@types/object-hash": "^3.0.6",
     "@types/seedrandom": "^3.0.8",
-    "@types/semver": "^7.5.8",
+    "@types/semver": "^7.7.0",
     "@types/tmp": "^0.2.6",
-    "@types/ws": "^8.5.14",
-    "@typescript-eslint/eslint-plugin": "^8.24.0",
-    "@vitest/coverage-v8": "^3.0.6",
-    "esbuild": "^0.25.0",
-    "eslint": "^9.20.1",
+    "@types/ws": "^8.18.1",
+    "@typescript-eslint/eslint-plugin": "^8.40.0",
+    "@vitest/coverage-v8": "^3.2.4",
+    "esbuild": "^0.25.9",
+    "eslint": "^9.34.0",
     "license-checker": "^25.0.1",
     "npm-run-all": "^4.1.5",
     "release-it": "^19.0.2",
     "ts-node": "^10.9.2",
+    "ts-node-dev": "^2.0.0",
     "typedoc": "^0.27.7",
     "typedoc-plugin-missing-exports": "^3.1.0",
     "typedoc-theme-hierarchy": "^5.0.4",
     "typedoc-umlclass": "^0.10.1",
     "typescript": "^5.7.3",
-    "vitest": "^3.0.6"
+    "vitest": "^3.2.4"
   },
   "dependencies": {
     "@eagleoutice/tree-sitter-r": "^1.1.2",
@@ -210,7 +212,7 @@
     "clipboardy": "^4.0.0",
     "command-line-args": "^6.0.1",
     "command-line-usage": "^7.0.3",
-    "joi": "^17.13.3",
+    "joi": "^18.0.1",
     "lz-string": "^1.5.0",
     "n-readlines": "^1.0.1",
     "n3": "^1.23.1",
@@ -221,7 +223,7 @@
     "semver": "^7.7.1",
     "tar": "^7.4.3",
     "tmp": "^0.2.3",
-    "ts-essentials": "^10.0.4",
+    "ts-essentials": "^10.1.1",
     "tslog": "^4.9.3",
     "web-tree-sitter": "^0.24.7",
     "ws": "^8.18.0",

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

@@ -1,5 +1,9 @@
-import type { CallContextQuery, CallContextQueryResult } from './call-context-query-format';
+import type { CallContextQuery, CallContextQueryResult, CallNameTypes, LinkTo } from './call-context-query-format';
 import type { BasicQueryData } from '../../base-query-format';
+export declare function promoteCallName(callName: CallNameTypes, exact?: boolean): RegExp | Set<string>;
+export type PromotedLinkTo = Omit<LinkTo, 'callName'> & {
+    callName: RegExp | Set<string>;
+};
 /**
  * Multi-stage call context query resolve.
  *

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

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.promoteCallName = promoteCallName;
 exports.executeCallContextQueries = executeCallContextQueries;
 const node_id_1 = require("../../../r-bridge/lang-4.x/ast/model/processing/node-id");
 const vertex_1 = require("../../../dataflow/graph/vertex");
@@ -42,6 +43,9 @@ function isSubCallQuery(query) {
 function exactCallNameRegex(name) {
     return new RegExp(`^(${name})$`);
 }
+function promoteCallName(callName, exact = false) {
+    return Array.isArray(callName) ? new Set(callName) : exact ? exactCallNameRegex(callName) : new RegExp(callName);
+}
 function promoteQueryCallNames(queries) {
     let requiresCfg = false;
     const promotedQueries = queries.map(q => {
@@ -49,30 +53,28 @@ function promoteQueryCallNames(queries) {
             requiresCfg = true;
             return {
                 ...q,
-                callName: q.callNameExact ? exactCallNameRegex(q.callName)
-                    : new RegExp(q.callName),
+                callName: promoteCallName(q.callName, q.callNameExact),
                 fileFilter: q.fileFilter && {
                     ...q.fileFilter,
-                    filter: new RegExp(q.fileFilter.filter)
+                    filter: promoteCallName(q.fileFilter.filter)
                 },
                 linkTo: Array.isArray(q.linkTo) ? q.linkTo.map(l => ({
                     ...l,
-                    callName: new RegExp(l.callName)
+                    callName: promoteCallName(l.callName)
                 })) : {
                     ...q.linkTo,
                     /* we have to add another promotion layer whenever we add something without this call name */
-                    callName: new RegExp(q.linkTo.callName)
+                    callName: promoteCallName(q.linkTo.callName)
                 }
             };
         }
         else {
             return {
                 ...q,
-                callName: q.callNameExact ? exactCallNameRegex(q.callName)
-                    : new RegExp(q.callName),
+                callName: promoteCallName(q.callName, q.callNameExact),
                 fileFilter: q.fileFilter && {
                     ...q.fileFilter,
-                    filter: new RegExp(q.fileFilter.filter)
+                    filter: promoteCallName(q.fileFilter.filter)
                 }
             };
         }
@@ -150,7 +152,7 @@ function doesFilepathMatch(file, filter) {
     if (file === undefined) {
         return filter.includeUndefinedFiles ?? true;
     }
-    return filter.filter.test(file);
+    return filter.filter instanceof RegExp ? filter.filter.test(file) : filter.filter.has(file);
 }
 function isParameterDefaultValue(nodeId, ast) {
     let node = ast.idMap.get(nodeId);
@@ -197,13 +199,13 @@ function executeCallContextQueries({ dataflow: { graph }, ast, config }, queries
             const targets = retrieveAllCallAliases(nodeId, graph);
             for (const [l, ids] of targets.entries()) {
                 for (const query of queriesWhichWantAliases) {
-                    if (query.callName.test(l)) {
+                    if (query.callName instanceof RegExp ? query.callName.test(l) : query.callName.has(l)) {
                         initialIdCollector.add(query.kind ?? '.', query.subkind ?? '.', (0, objects_1.compactRecord)({ id: nodeId, name: info.name, aliasRoots: ids }));
                     }
                 }
             }
         }
-        for (const query of promotedQueries.filter(q => !q.includeAliases && q.callName.test(info.name))) {
+        for (const query of promotedQueries.filter(q => !q.includeAliases && (q.callName instanceof RegExp ? q.callName.test(info.name) : q.callName.has(info.name)))) {
             const file = ast.idMap.get(nodeId)?.info.file;
             if (!doesFilepathMatch(file, query.fileFilter)) {
                 continue;
@@ -223,7 +225,7 @@ function executeCallContextQueries({ dataflow: { graph }, ast, config }, queries
                 continue;
             }
             let linkedIds = undefined;
-            if (cfg && isSubCallQuery(query)) {
+            if (cfg && 'linkTo' in query && query.linkTo !== undefined) {
                 const linked = Array.isArray(query.linkTo) ? query.linkTo : [query.linkTo];
                 for (const link of linked) {
                     /* if we have a linkTo query, we have to find the last call */

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': {