Convert to match style from DB panel

extensions/ql-vscode/src/local-queries/local-queries.ts

@@ -48,10 +48,7 @@ import { SkeletonQueryWizard } from "../skeleton-query-wizard";
 import { LocalQueryRun } from "./local-query-run";
 import { createMultiSelectionCommand } from "../common/vscode/selection-commands";
 import { findLanguage } from "../codeql-cli/query-language";
-import {
-  QueryTreeQueryItem,
-  QueryTreeViewItem,
-} from "../queries-panel/query-tree-view-item";
+import { QueryTreeViewItem } from "../queries-panel/query-tree-view-item";
 
 interface DatabaseQuickPickItem extends QuickPickItem {
   databaseItem: DatabaseItem;
@@ -133,7 +130,7 @@ export class LocalQueries extends DisposableObject {
   private async runQueryFromQueriesPanel(
     queryTreeViewItem: QueryTreeViewItem,
   ): Promise<void> {
-    if (queryTreeViewItem instanceof QueryTreeQueryItem) {
+    if (queryTreeViewItem.path !== undefined) {
       await this.runQuery(Uri.file(queryTreeViewItem.path));
     }
   }
@@ -141,12 +138,13 @@ export class LocalQueries extends DisposableObject {
   private async runQueriesFromQueriesPanel(
     queryTreeViewItem: QueryTreeViewItem,
   ): Promise<void> {
-    if (queryTreeViewItem instanceof QueryTreeQueryItem) {
-      const uris = queryTreeViewItem.children.map((child) =>
-        Uri.file(child.path),
-      );
-      await this.runQueries(uris);
+    const uris = [];
+    for (const child of queryTreeViewItem.children) {
+      if (child.path !== undefined) {
+        uris.push(Uri.file(child.path));
+      }
     }
+    await this.runQueries(uris);
   }
 
   private async runQuery(uri: Uri | undefined): Promise<void> {

extensions/ql-vscode/src/queries-panel/query-tree-data-provider.ts

@@ -1,8 +1,9 @@
 import { Event, EventEmitter, TreeDataProvider, TreeItem } from "vscode";
 import {
-  QueryTreeQueryItem,
-  QueryTreeTextItem,
   QueryTreeViewItem,
+  createQueryTreeLeafItem,
+  createQueryTreeNodeItem,
+  createQueryTreeTextItem,
 } from "./query-tree-view-item";
 import { DisposableObject } from "../common/disposable-object";
 import { FileTreeNode } from "../common/file-tree-nodes";
@@ -50,17 +51,24 @@ export class QueryTreeDataProvider
 
   private convertFileTreeNode(
     fileTreeDirectory: FileTreeNode<string>,
-  ): QueryTreeQueryItem {
-    return new QueryTreeQueryItem(
-      fileTreeDirectory.name,
-      fileTreeDirectory.path,
-      fileTreeDirectory.data,
-      fileTreeDirectory.children.map(this.convertFileTreeNode.bind(this)),
-    );
+  ): QueryTreeViewItem {
+    if (fileTreeDirectory.children.length === 0) {
+      return createQueryTreeLeafItem(
+        fileTreeDirectory.name,
+        fileTreeDirectory.path,
+        fileTreeDirectory.data,
+      );
+    } else {
+      return createQueryTreeNodeItem(
+        fileTreeDirectory.name,
+        fileTreeDirectory.path,
+        fileTreeDirectory.children.map(this.convertFileTreeNode.bind(this)),
+      );
+    }
   }
 
   private noQueriesTreeViewItem(): QueryTreeViewItem {
-    return new QueryTreeTextItem(
+    return createQueryTreeTextItem(
       "This workspace doesn't contain any CodeQL queries at the moment.",
     );
   }
@@ -83,10 +91,8 @@ export class QueryTreeDataProvider
     if (!item) {
       // We're at the root.
       return this.queryTreeItems;
-    } else if (item instanceof QueryTreeQueryItem) {
-      return item.children;
     } else {
-      return [];
+      return item.children;
     }
   }
 }

extensions/ql-vscode/src/queries-panel/query-tree-view-item.ts

@@ -1,38 +1,45 @@
 import * as vscode from "vscode";
 
-export abstract class QueryTreeViewItem extends vscode.TreeItem {
-  protected constructor(name: string) {
-    super(name);
-  }
-}
-
-export class QueryTreeQueryItem extends QueryTreeViewItem {
+export class QueryTreeViewItem extends vscode.TreeItem {
   constructor(
     name: string,
-    public readonly path: string,
-    language: string | undefined,
-    public readonly children: QueryTreeQueryItem[],
+    public readonly path: string | undefined,
+    public readonly children: QueryTreeViewItem[],
   ) {
     super(name);
-    this.tooltip = path;
-    if (this.children.length === 0) {
-      this.description = language;
-      this.collapsibleState = vscode.TreeItemCollapsibleState.None;
-      this.contextValue = "queryFile";
-      this.command = {
-        title: "Open",
-        command: "vscode.open",
-        arguments: [vscode.Uri.file(path)],
-      };
-    } else {
-      this.collapsibleState = vscode.TreeItemCollapsibleState.Collapsed;
-      this.contextValue = "queryFolder";
-    }
   }
 }
 
-export class QueryTreeTextItem extends QueryTreeViewItem {
-  constructor(text: string) {
-    super(text);
-  }
+export function createQueryTreeNodeItem(
+  name: string,
+  path: string,
+  children: QueryTreeViewItem[],
+): QueryTreeViewItem {
+  const item = new QueryTreeViewItem(name, path, children);
+  item.tooltip = path;
+  item.collapsibleState = vscode.TreeItemCollapsibleState.Collapsed;
+  item.contextValue = "queryFolder";
+  return item;
+}
+
+export function createQueryTreeLeafItem(
+  name: string,
+  path: string,
+  language: string | undefined,
+): QueryTreeViewItem {
+  const item = new QueryTreeViewItem(name, path, []);
+  item.tooltip = path;
+  item.description = language;
+  item.collapsibleState = vscode.TreeItemCollapsibleState.None;
+  item.contextValue = "queryFile";
+  item.command = {
+    title: "Open",
+    command: "vscode.open",
+    arguments: [vscode.Uri.file(path)],
+  };
+  return item;
+}
+
+export function createQueryTreeTextItem(text: string): QueryTreeViewItem {
+  return new QueryTreeViewItem(text, undefined, []);
 }

extensions/ql-vscode/src/variant-analysis/variant-analysis-manager.ts

@@ -76,10 +76,7 @@ import {
   showAndLogInformationMessage,
   showAndLogWarningMessage,
 } from "../common/logging";
-import {
-  QueryTreeQueryItem,
-  QueryTreeViewItem,
-} from "../queries-panel/query-tree-view-item";
+import { QueryTreeViewItem } from "../queries-panel/query-tree-view-item";
 
 const maxRetryCount = 3;
 
@@ -194,7 +191,7 @@ export class VariantAnalysisManager
   private async runVariantAnalysisFromQueriesPanel(
     queryTreeViewItem: QueryTreeViewItem,
   ): Promise<void> {
-    if (queryTreeViewItem instanceof QueryTreeQueryItem) {
+    if (queryTreeViewItem.path !== undefined) {
       await this.runVariantAnalysisFromCommand(
         Uri.file(queryTreeViewItem.path),
       );

extensions/ql-vscode/test/vscode-tests/minimal-workspace/queries-panel/query-tree-data-provider.test.ts

@@ -5,8 +5,9 @@ import {
 } from "../../../../src/common/file-tree-nodes";
 import { QueryTreeDataProvider } from "../../../../src/queries-panel/query-tree-data-provider";
 import {
-  QueryTreeQueryItem,
-  QueryTreeTextItem,
+  createQueryTreeLeafItem,
+  createQueryTreeNodeItem,
+  createQueryTreeTextItem,
 } from "../../../../src/queries-panel/query-tree-view-item";
 
 describe("QueryTreeDataProvider", () => {
@@ -27,7 +28,7 @@ describe("QueryTreeDataProvider", () => {
       });
 
       expect(dataProvider.getChildren()).toEqual([
-        new QueryTreeTextItem(
+        createQueryTreeTextItem(
           "This workspace doesn't contain any CodeQL queries at the moment.",
         ),
       ]);
@@ -58,24 +59,14 @@ describe("QueryTreeDataProvider", () => {
       });
 
       expect(dataProvider.getChildren()).toEqual([
-        new QueryTreeQueryItem("dir1", "dir1", undefined, [
-          new QueryTreeQueryItem("dir2", "dir1/dir2", undefined, [
-            new QueryTreeQueryItem(
-              "file1",
-              "dir1/dir2/file1",
-              "javascript",
-              [],
-            ),
-            new QueryTreeQueryItem(
-              "file2",
-              "dir1/dir2/file2",
-              "javascript",
-              [],
-            ),
+        createQueryTreeNodeItem("dir1", "dir1", [
+          createQueryTreeNodeItem("dir2", "dir1/dir2", [
+            createQueryTreeLeafItem("file1", "dir1/dir2/file1", "javascript"),
+            createQueryTreeLeafItem("file2", "dir1/dir2/file2", "javascript"),
           ]),
         ]),
-        new QueryTreeQueryItem("dir3", "dir3", undefined, [
-          new QueryTreeQueryItem("file3", "dir3/file3", "javascript", []),
+        createQueryTreeNodeItem("dir3", "dir3", [
+          createQueryTreeLeafItem("file3", "dir3/file3", "javascript"),
         ]),
       ]);
     });