feat(workspace-tree): sync open editor with workspace tree

The implementation of reveal() in the tree view required proper parent-child
relationships and package path resolution. The changes ensure that:

1. The tree view can properly navigate and reveal items by maintaining
   correct parent references
2. Package paths are consistently resolved through the parent chain
3. The selected item in the tree view is synchronized with the currently open editor

A cache of BazelPackageTreeItems was added to improve performance by:

- Reducing redundant package path calculations
- Avoiding bazel queries performed by existing getChildren operator
- Minimizing repeated string operations when resolving package paths

Part of #353

Author: cbandera

.github/workflows/build.yml

@@ -40,6 +40,17 @@ jobs:
       - name: Lint
         run: npm run check-lint
 
+      - uses: bazel-contrib/[email protected]
+        with:
+          bazelisk-cache: true
+          disk-cache: false
+          repository-cache: false
+          module-root: ${{ github.workspace }}/test/bazel_workspace
+
+      - name: Build Bazel workspace to assure it is working & warm up cache
+        run: bazel build //...
+        working-directory: ${{ github.workspace }}/test/bazel_workspace/
+
       # Required for the test cases
       - name: Install system dependencies
         run: sudo apt install -y binutils rustfilt

eslint.config.js

@@ -8,7 +8,14 @@ const jsdoc = require("eslint-plugin-jsdoc");
 module.exports = [
   // Global ignores
   {
-    ignores: ["out/", "src/protos/protos.js", "src/protos/protos.d.ts"],
+    ignores: [
+      "out/",
+      "src/protos/protos.js",
+      "src/protos/protos.d.ts",
+      ".vscode-test/",
+      "node_modules/",
+      "dist/",
+    ],
   },
 
   // TypeScript configuration

src/extension/extension.ts

@@ -33,24 +33,31 @@ import { activateCommandVariables } from "./command_variables";
 import { activateTesting } from "../test-explorer";
 import { activateWrapperCommands } from "./bazel_wrapper_commands";
 
+// Global reference to the workspace tree provider for testing
+export let _workspaceTreeProvider: BazelWorkspaceTreeProvider;
+
 /**
  * Called when the extension is activated; that is, when its first command is
  * executed.
  *
  * @param context The extension context.
  */
 export async function activate(context: vscode.ExtensionContext) {
-  const workspaceTreeProvider =
+  // Initialize the workspace tree provider
+  _workspaceTreeProvider =
     BazelWorkspaceTreeProvider.fromExtensionContext(context);
-  context.subscriptions.push(workspaceTreeProvider);
+  context.subscriptions.push(_workspaceTreeProvider);
 
+  // Initialize other components
   const codeLensProvider = new BazelBuildCodeLensProvider(context);
   const buildifierDiagnostics = new BuildifierDiagnosticsManager();
   let completionItemProvider: BazelCompletionItemProvider | null = null;
 
+  // Initialize other parts of the extension
   const config = vscode.workspace.getConfiguration("bazel");
   const lspEnabled = !!config.get<string>("lsp.command");
 
+  // Set up LSP if enabled
   if (lspEnabled) {
     const lspClient = createLsp(config);
 
@@ -89,17 +96,26 @@ export async function activate(context: vscode.ExtensionContext) {
   // eslint-disable-next-line @typescript-eslint/no-floating-promises
   vscode.commands.executeCommand("setContext", "bazel.lsp.enabled", lspEnabled);
 
+  // Create and register the tree view
+  const treeView = vscode.window.createTreeView("bazelWorkspace", {
+    treeDataProvider: _workspaceTreeProvider,
+    showCollapseAll: true,
+  });
+  _workspaceTreeProvider.setTreeView(treeView);
+
   context.subscriptions.push(
-    vscode.window.registerTreeDataProvider(
-      "bazelWorkspace",
-      workspaceTreeProvider,
-    ),
+    treeView,
     // Commands
     ...activateWrapperCommands(),
+
+    // Register command to manually refresh the tree view
+    vscode.commands.registerCommand("bazel.workspaceTree.refresh", () => {
+      _workspaceTreeProvider.refresh();
+    }),
     vscode.commands.registerCommand("bazel.refreshBazelBuildTargets", () => {
       // eslint-disable-next-line @typescript-eslint/no-floating-promises
       completionItemProvider?.refresh();
-      workspaceTreeProvider.refresh();
+      _workspaceTreeProvider.refresh();
     }),
     // URI handler
     vscode.window.registerUriHandler({

src/workspace-tree/bazel_package_tree_item.ts

@@ -38,17 +38,16 @@ export class BazelPackageTreeItem
   /**
    * Initializes a new tree item with the given workspace path and package path.
    *
-   * @param workspacePath The path to the VS Code workspace folder.
+   * @param resources The resources for the extension.
+   * @param workspaceInfo The workspace information.
+   * @param parent The parent tree item of this item.
    * @param packagePath The path to the build package that this item represents.
-   * @param parentPackagePath The path to the build package of the tree item
-   * that is this item's parent, which indicates how much of
-   * {@code packagePath} should be stripped for the item's label.
    */
   constructor(
     private readonly resources: Resources,
     private readonly workspaceInfo: BazelWorkspaceInfo,
+    private readonly parent: IBazelTreeItem,
     private readonly packagePath: string,
-    private readonly parentPackagePath: string,
   ) {}
 
   public mightHaveChildren(): boolean {
@@ -67,21 +66,27 @@ export class BazelPackageTreeItem
       return new BazelTargetTreeItem(
         this.resources,
         this.workspaceInfo,
+        this as unknown as IBazelTreeItem,
         target,
       );
     });
     return (this.directSubpackages as IBazelTreeItem[]).concat(targets);
   }
 
+  public getParent(): vscode.ProviderResult<IBazelTreeItem> {
+    return this.parent;
+  }
+
   public getLabel(): string {
     // If this is a top-level package, include the leading double-slash on the
     // label.
-    if (this.parentPackagePath.length === 0) {
+    const parentPackagePath = this.parent.getPackagePath();
+    if (parentPackagePath.length === 0) {
       return `//${this.packagePath}`;
     }
     // Otherwise, strip off the part of the package path that came from the
     // parent item (along with the slash).
-    return this.packagePath.substring(this.parentPackagePath.length + 1);
+    return this.packagePath.substring(parentPackagePath.length + 1);
   }
 
   public getIcon(): vscode.ThemeIcon {
@@ -107,4 +112,8 @@ export class BazelPackageTreeItem
       workspaceInfo: this.workspaceInfo,
     };
   }
+
+  public getPackagePath(): string {
+    return this.packagePath;
+  }
 }

src/workspace-tree/bazel_target_tree_item.ts

@@ -28,12 +28,16 @@ export class BazelTargetTreeItem
    * Initializes a new tree item with the given query result representing a
    * build target.
    *
+   * @param resources The resources for the extension.
+   * @param workspaceInfo The workspace information.
+   * @param parent The parent tree item of this item.
    * @param target An object representing a build target that was produced by a
    * query.
    */
   constructor(
     private readonly resources: Resources,
     private readonly workspaceInfo: BazelWorkspaceInfo,
+    private readonly parent: IBazelTreeItem,
     private readonly target: blaze_query.ITarget,
   ) {}
 
@@ -45,6 +49,14 @@ export class BazelTargetTreeItem
     return Promise.resolve([]);
   }
 
+  public getParent(): vscode.ProviderResult<IBazelTreeItem> {
+    return this.parent;
+  }
+
+  public getPackagePath(): string {
+    return this.parent.getPackagePath();
+  }
+
   public getLabel(): string {
     const fullPath = this.target.rule.name;
     const colonIndex = fullPath.lastIndexOf(":");

src/workspace-tree/bazel_tree_item.ts

@@ -33,6 +33,9 @@ export interface IBazelTreeItem {
   /** Returns a promise for the children of the tree item. */
   getChildren(): Thenable<IBazelTreeItem[]>;
 
+  /** Returns the parent of the tree item. */
+  getParent(): vscode.ProviderResult<IBazelTreeItem>;
+
   /** Returns the text label of the tree item. */
   getLabel(): string;
 
@@ -45,6 +48,14 @@ export interface IBazelTreeItem {
    */
   getTooltip(): string | undefined;
 
+  /**
+   * Returns the package path of the tree item.
+   * For workspace folders, this returns an empty string.
+   * For packages, this returns the path relative to the workspace root.
+   * For targets, this returns the path of the package that contains the target.
+   */
+  getPackagePath(): string;
+
   /** Returns the command that should be executed when the item is selected. */
   getCommand(): vscode.Command | undefined;
 

src/workspace-tree/bazel_workspace_folder_tree_item.ts

@@ -23,6 +23,12 @@ import { Resources } from "../extension/resources";
 
 /** A tree item representing a workspace folder. */
 export class BazelWorkspaceFolderTreeItem implements IBazelTreeItem {
+  /**
+   * Stores all BazelPackageTreeItems in sorted order (by path length and in descending order).
+   * This is used to find the most specific match for a given file path.
+   */
+  private sortedPackageTreeItems: BazelPackageTreeItem[] = [];
+
   /**
    * Initializes a new tree item with the given workspace folder.
    *
@@ -31,7 +37,9 @@ export class BazelWorkspaceFolderTreeItem implements IBazelTreeItem {
   constructor(
     private readonly resources: Resources,
     private readonly workspaceInfo: BazelWorkspaceInfo,
-  ) {}
+  ) {
+    void this.getDirectoryItems(); // Initialize the tree items
+  }
 
   public mightHaveChildren(): boolean {
     return true;
@@ -41,6 +49,10 @@ export class BazelWorkspaceFolderTreeItem implements IBazelTreeItem {
     return this.getDirectoryItems();
   }
 
+  public getParent(): vscode.ProviderResult<IBazelTreeItem> {
+    return undefined;
+  }
+
   public getLabel(): string {
     return this.workspaceInfo.workspaceFolder.name;
   }
@@ -61,6 +73,31 @@ export class BazelWorkspaceFolderTreeItem implements IBazelTreeItem {
     return "workspaceFolder";
   }
 
+  public getWorkspaceInfo(): BazelWorkspaceInfo {
+    return this.workspaceInfo;
+  }
+
+  public getPackagePath(): string {
+    return "";
+  }
+
+  /**
+   * Finds the package that contains the given relative file path.
+   * Uses the presorted list of package items for efficient lookups.
+   * Find the first package that is a prefix of the relative path
+   *
+   * @param relativeFilePath The filepath relative to the workspace folder.
+   * @returns The package tree item that contains the given relative file path,
+   * or undefined if no such package exists.
+   */
+  public getClosestPackageTreeItem(
+    relativeFilePath: string,
+  ): BazelPackageTreeItem | undefined {
+    return this.sortedPackageTreeItems.find((pkg) =>
+      relativeFilePath.startsWith(pkg.getPackagePath()),
+    );
+  }
+
   /**
    * Recursively creates the tree items that represent packages found in a Bazel
    * query.
@@ -73,16 +110,15 @@ export class BazelWorkspaceFolderTreeItem implements IBazelTreeItem {
    * common prefixes should be searched.
    * @param treeItems An array into which the tree items created at this level
    * in the tree will be pushed.
-   * @param parentPackagePath The parent package path of the items being created
-   * by this call, which is used to trim the package prefix from labels in
-   * the tree items.
+   * @param parent The parent tree item of the items being created by this call,
+   * which is used to trim the package prefix from labels in the tree items.
    */
   private buildPackageTree(
     packagePaths: string[],
     startIndex: number,
     endIndex: number,
     treeItems: BazelPackageTreeItem[],
-    parentPackagePath: string,
+    parent: IBazelTreeItem,
   ) {
     // We can assume that the caller has sorted the packages, so we scan them to
     // find groupings into which we should traverse more deeply. For example, if
@@ -128,16 +164,16 @@ export class BazelWorkspaceFolderTreeItem implements IBazelTreeItem {
       const item = new BazelPackageTreeItem(
         this.resources,
         this.workspaceInfo,
+        parent,
         packagePath,
-        parentPackagePath,
       );
       treeItems.push(item);
       this.buildPackageTree(
         packagePaths,
         groupStart + 1,
         groupEnd,
         item.directSubpackages,
-        packagePath,
+        item,
       );
 
       // Move our index to start looking for more groups in the next iteration
@@ -175,7 +211,7 @@ export class BazelWorkspaceFolderTreeItem implements IBazelTreeItem {
       0,
       packagePaths.length,
       topLevelItems,
-      "",
+      this,
     );
 
     // Now collect any targets in the directory also (this can fail since
@@ -191,10 +227,37 @@ export class BazelWorkspaceFolderTreeItem implements IBazelTreeItem {
       return new BazelTargetTreeItem(
         this.resources,
         this.workspaceInfo,
+        this as unknown as IBazelTreeItem,
         target,
       );
     });
 
+    // Cache all packages after building the tree
+    this.collectAndSortPackageTreeItems(topLevelItems);
+
     return Promise.resolve((topLevelItems as IBazelTreeItem[]).concat(targets));
   }
+
+  /**
+   * Collect, sort and store packages for later lookup
+   */
+  private collectAndSortPackageTreeItems(items: BazelPackageTreeItem[]): void {
+    this.sortedPackageTreeItems = [];
+    this.collectAllPackageTreeItems(items);
+    this.sortedPackageTreeItems.sort(
+      (a, b) => b.getPackagePath().length - a.getPackagePath().length,
+    );
+  }
+
+  /**
+   * Recursively collect all children of type BazelPackageTreeItem
+   */
+  private collectAllPackageTreeItems(items: BazelPackageTreeItem[]): void {
+    for (const item of items) {
+      this.sortedPackageTreeItems.push(item);
+      if (item.directSubpackages) {
+        this.collectAllPackageTreeItems(item.directSubpackages);
+      }
+    }
+  }
 }