[Query API] Flag For Exact Name Matching (#1058)

feat(query): exact name flag

src/documentation/print-query-wiki.ts

@@ -31,7 +31,7 @@ registerQueryDocumentation('call-context', {
 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.
+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. Please note, that if you do not use Regex-Anchors, the query will match any function name that contains the given pattern (you can set the \`callNameExact\` property to \`true\` to automatically add the \`^...$\` anchors).
 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:

src/queries/catalog/call-context-query/call-context-query-executor.ts

@@ -106,15 +106,20 @@ function isSubCallQuery(query: CallContextQuery): query is SubCallContextQueryFo
 	return 'linkTo' in query;
 }
 
+function exactCallNameRegex(name: RegExp | string): RegExp {
+	return new RegExp(`^${name}$`);
+}
+
 function promoteQueryCallNames(queries: readonly CallContextQuery[]): { promotedQueries: CallContextQuery<RegExp>[], requiresCfg: boolean } {
 	let requiresCfg = false;
 	const promotedQueries = queries.map(q => {
 		if(isSubCallQuery(q)) {
 			requiresCfg = true;
 			return {
 				...q,
-				callName: new RegExp(q.callName),
-				linkTo:   {
+				callName: q.callNameExact ? exactCallNameRegex(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)
@@ -123,7 +128,8 @@ function promoteQueryCallNames(queries: readonly CallContextQuery[]): { promoted
 		} else {
 			return {
 				...q,
-				callName: new RegExp(q.callName)
+				callName: q.callNameExact ? exactCallNameRegex(q.callName)
+					: new RegExp(q.callName)
 			};
 		}
 	});

src/queries/catalog/call-context-query/call-context-query-format.ts

@@ -18,6 +18,10 @@ export interface DefaultCallContextQueryFormat<CallName extends RegExp | string>
 	readonly type:            'call-context';
 	/** Regex regarding the function name, please note that strings will be interpreted as regular expressions too! */
 	readonly callName:        CallName;
+	/**
+	 * Should we automatically add the `^` and `$` anchors to the regex to make it an exact match?
+	 */
+	readonly callNameExact?:  boolean;
 	/** kind may be a step or anything that you attach to the call, this can be used to group calls together (e.g., linking `ggplot` to `visualize`). Defaults to `.` */
 	readonly kind?:           string;
 	/** subkinds are used to uniquely identify the respective call type when grouping the output (e.g., the normalized name, linking `ggplot` to `plot`). Defaults to `.` */

src/queries/query-schema.ts

@@ -4,6 +4,7 @@ import { CallTargets } from './catalog/call-context-query/call-context-query-for
 export const CallContextQuerySchema = Joi.object({
 	type:           Joi.string().valid('call-context').required().description('The type of the query.'),
 	callName:       Joi.string().required().description('Regex regarding the function name!'),
+	callNameExact:  Joi.boolean().optional().description('Should we automatically add the `^` and `$` anchors to the regex to make it an exact match?'),
 	kind:           Joi.string().optional().description('The kind of the call, this can be used to group calls together (e.g., linking `plot` to `visualize`). Defaults to `.`'),
 	subkind:        Joi.string().optional().description('The subkind of the call, this can be used to uniquely identify the respective call type when grouping the output (e.g., the normalized name, linking `ggplot` to `plot`). Defaults to `.`'),
 	callTargets:    Joi.string().valid(...Object.values(CallTargets)).optional().description('Call targets the function may have. This defaults to `any`. Request this specifically to gain all call targets we can resolve.'),

test/functionality/dataflow/query/call-context-query-tests.ts

@@ -121,4 +121,9 @@ describe('Call Context Query', withShell(shell => {
 			}
 		}));
 	});
+	describe('Exact Names', () => {
+		testQuery('Contained Match (expl undefined)', 'foo()', [q(/o/, { })], r([{ id: 1 }]));
+		testQuery('Contained Match (expl. false)', 'foo()', [q(/o/, { callNameExact: false })], r([{ id: 1 }]));
+		testQuery('No Contained Match', 'foo()', [q(/o/, { callNameExact: true })], baseResult({}));
+	});
 }));