Remove separation between generate queries options

extensions/ql-vscode/src/model-editor/generate.ts

@@ -9,40 +9,26 @@ import { ModeledMethod } from "./modeled-method";
 import { runQuery } from "../local-queries/run-query";
 import { QueryConstraints, resolveQueries } from "../local-queries";
 import { DecodedBqrs } from "../common/bqrs-cli-types";
-
+type GenerateQueriesOptions = {
-/**
- * Options that are set by the caller of `runGenerateQueries`.
- */
-type GenerateQueriesQueryOptions = {
   queryConstraints: QueryConstraints;
   filterQueries?: (queryPath: string) => boolean;
   parseResults: (
     queryPath: string,
     results: DecodedBqrs,
   ) => ModeledMethod[] | Promise<ModeledMethod[]>;
-};
+  onResults: (results: ModeledMethod[]) => void | Promise<void>;
 
-/**
- * Options that are passed through by the caller of `runGenerateQueries`.
- */
-type GenerateQueriesOptions = {
   cliServer: CodeQLCliServer;
   queryRunner: QueryRunner;
   queryStorageDir: string;
   databaseItem: DatabaseItem;
   progress: ProgressCallback;
   token: CancellationToken;
-  onResults: (results: ModeledMethod[]) => void | Promise<void>;
 };
 
-export async function runGenerateQueries(
+export async function runGenerateQueries(options: GenerateQueriesOptions) {
-  {
+  const { queryConstraints, filterQueries, parseResults, onResults } = options;
-    queryConstraints,
+
-    filterQueries,
-    parseResults,
-  }: GenerateQueriesQueryOptions,
-  { onResults, ...options }: GenerateQueriesOptions,
-) {
   options.progress({
     message: "Resolving queries",
     step: 1,
@@ -84,7 +70,7 @@ async function runSingleGenerateQuery(
     databaseItem,
     progress,
     token,
-  }: Omit<GenerateQueriesOptions, "onResults">,
+  }: GenerateQueriesOptions,
 ): Promise<DecodedBqrs | undefined> {
   const queryBasename = basename(queryPath);
 

extensions/ql-vscode/src/model-editor/model-editor-view.ts

@@ -509,30 +509,26 @@ export class ModelEditorView extends AbstractWebview<
         });
 
         try {
-          await runGenerateQueries(
+          await runGenerateQueries({
-            {
+            queryConstraints: modelGeneration.queryConstraints,
-              queryConstraints: modelGeneration.queryConstraints,
+            filterQueries: modelGeneration.filterQueries,
-              filterQueries: modelGeneration.filterQueries,
+            parseResults: (queryPath, results) =>
-              parseResults: (queryPath, results) =>
+              modelGeneration.parseResults(
-                modelGeneration.parseResults(
+                queryPath,
-                  queryPath,
+                results,
-                  results,
+                modelsAsDataLanguage,
-                  modelsAsDataLanguage,
+                this.app.logger,
-                  this.app.logger,
+              ),
-                ),
+            onResults: async (modeledMethods) => {
+              this.addModeledMethodsFromArray(modeledMethods);
             },
-            {
+            cliServer: this.cliServer,
-              cliServer: this.cliServer,
+            queryRunner: this.queryRunner,
-              queryRunner: this.queryRunner,
+            queryStorageDir: this.queryStorageDir,
-              queryStorageDir: this.queryStorageDir,
+            databaseItem: addedDatabase ?? this.databaseItem,
-              databaseItem: addedDatabase ?? this.databaseItem,
+            progress,
-              onResults: async (modeledMethods) => {
+            token: tokenSource.token,
-                this.addModeledMethodsFromArray(modeledMethods);
+          });
-              },
-              progress,
-              token: tokenSource.token,
-            },
-          );
         } catch (e: unknown) {
           void showAndLogExceptionWithTelemetry(
             this.app.logger,

extensions/ql-vscode/test/vscode-tests/no-workspace/model-editor/generate.test.ts

@@ -122,23 +122,21 @@ describe("runGenerateQueries", () => {
       queryStorageDir: "/tmp/queries",
       progress: jest.fn(),
       token: new CancellationTokenSource().token,
-      onResults,
     };
 
-    await runGenerateQueries(
+    await runGenerateQueries({
-      {
+      queryConstraints: modelGeneration.queryConstraints,
-        queryConstraints: modelGeneration.queryConstraints,
+      filterQueries: modelGeneration.filterQueries,
-        filterQueries: modelGeneration.filterQueries,
+      parseResults: (queryPath, results) =>
-        parseResults: (queryPath, results) =>
+        modelGeneration.parseResults(
-          modelGeneration.parseResults(
+          queryPath,
-            queryPath,
+          results,
-            results,
+          modelsAsDataLanguage,
-            modelsAsDataLanguage,
+          createMockLogger(),
-            createMockLogger(),
+        ),
-          ),
+      onResults,
-      },
+      ...options,
-      options,
+    });
-    );
     expect(onResults).toHaveBeenCalledWith([
       {
         input: "Argument[self]",