Fix parent folder checkbox not auto-checked when all children are marked as viewed

Eagerly update ancestor directory checkbox states in processCheckboxUpdates
before refresh, rather than relying solely on getTreeItem() which may not
apply checkboxState changes with manageCheckboxStateManually: true.

Co-authored-by: alexr00 <38270282+alexr00@users.noreply.github.com>
Agent-Logs-Url: https://github.com/microsoft/vscode-pull-request-github/sessions/0fafc95a-8baa-49ec-8f27-602e4bcf370a

Author: Copilot

src/test/view/treeNodes/directoryTreeNode.test.ts

@@ -0,0 +1,201 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import { default as assert } from 'assert';
+import { DirectoryTreeNode } from '../../../view/treeNodes/directoryTreeNode';
+import { TreeNode, TreeNodeParent } from '../../../view/treeNodes/treeNode';
+
+/**
+ * Minimal mock for a file-like child node that supports checkboxState.
+ * This is NOT a DirectoryTreeNode so allChildrenViewed() treats it as a leaf file.
+ */
+class MockFileNode extends TreeNode {
+	public checkboxState?: { state: vscode.TreeItemCheckboxState; tooltip?: string; accessibilityInformation?: vscode.AccessibilityInformation };
+	constructor(parent: TreeNodeParent) {
+		super(parent);
+	}
+	getTreeItem(): vscode.TreeItem {
+		return this;
+	}
+}
+
+function createMockParent(): TreeNodeParent {
+	return {
+		refresh: () => { },
+		reveal: () => Promise.resolve(),
+		children: undefined,
+		view: {} as any
+	} as any;
+}
+
+describe('DirectoryTreeNode', function () {
+	describe('allChildrenViewed', function () {
+		it('returns true when all file children are checked', function () {
+			const dirNode = new DirectoryTreeNode(createMockParent(), 'src');
+
+			const file1 = new MockFileNode(dirNode);
+			file1.checkboxState = { state: vscode.TreeItemCheckboxState.Checked };
+			const file2 = new MockFileNode(dirNode);
+			file2.checkboxState = { state: vscode.TreeItemCheckboxState.Checked };
+
+			(dirNode._children as any[]).push(file1, file2);
+
+			assert.strictEqual(dirNode.allChildrenViewed(), true);
+		});
+
+		it('returns false when some file children are unchecked', function () {
+			const dirNode = new DirectoryTreeNode(createMockParent(), 'src');
+
+			const file1 = new MockFileNode(dirNode);
+			file1.checkboxState = { state: vscode.TreeItemCheckboxState.Checked };
+			const file2 = new MockFileNode(dirNode);
+			file2.checkboxState = { state: vscode.TreeItemCheckboxState.Unchecked };
+
+			(dirNode._children as any[]).push(file1, file2);
+
+			assert.strictEqual(dirNode.allChildrenViewed(), false);
+		});
+
+		it('returns false when a file child has no checkboxState', function () {
+			const dirNode = new DirectoryTreeNode(createMockParent(), 'src');
+
+			const file1 = new MockFileNode(dirNode);
+			file1.checkboxState = { state: vscode.TreeItemCheckboxState.Checked };
+			const file2 = new MockFileNode(dirNode);
+			// file2 has no checkboxState
+
+			(dirNode._children as any[]).push(file1, file2);
+
+			assert.strictEqual(dirNode.allChildrenViewed(), false);
+		});
+
+		it('returns true when nested directories have all children checked', function () {
+			const parentDir = new DirectoryTreeNode(createMockParent(), 'src');
+			const childDir = new DirectoryTreeNode(parentDir, 'utils');
+
+			const file1 = new MockFileNode(childDir);
+			file1.checkboxState = { state: vscode.TreeItemCheckboxState.Checked };
+
+			(childDir._children as any[]).push(file1);
+			parentDir._children.push(childDir);
+
+			assert.strictEqual(parentDir.allChildrenViewed(), true);
+		});
+
+		it('returns false when nested directories have unchecked children', function () {
+			const parentDir = new DirectoryTreeNode(createMockParent(), 'src');
+			const childDir = new DirectoryTreeNode(parentDir, 'utils');
+
+			const file1 = new MockFileNode(childDir);
+			file1.checkboxState = { state: vscode.TreeItemCheckboxState.Unchecked };
+
+			(childDir._children as any[]).push(file1);
+			parentDir._children.push(childDir);
+
+			assert.strictEqual(parentDir.allChildrenViewed(), false);
+		});
+
+		it('returns true when empty directory has no children', function () {
+			const dirNode = new DirectoryTreeNode(createMockParent(), 'empty');
+			assert.strictEqual(dirNode.allChildrenViewed(), true);
+		});
+	});
+
+	describe('updateCheckboxFromChildren', function () {
+		it('sets checkbox to Checked when all children are viewed', function () {
+			const dirNode = new DirectoryTreeNode(createMockParent(), 'src');
+
+			const file1 = new MockFileNode(dirNode);
+			file1.checkboxState = { state: vscode.TreeItemCheckboxState.Checked };
+
+			(dirNode._children as any[]).push(file1);
+
+			dirNode.updateCheckboxFromChildren();
+
+			assert.strictEqual(dirNode.checkboxState?.state, vscode.TreeItemCheckboxState.Checked);
+		});
+
+		it('sets checkbox to Unchecked when not all children are viewed', function () {
+			const dirNode = new DirectoryTreeNode(createMockParent(), 'src');
+
+			const file1 = new MockFileNode(dirNode);
+			file1.checkboxState = { state: vscode.TreeItemCheckboxState.Checked };
+			const file2 = new MockFileNode(dirNode);
+			file2.checkboxState = { state: vscode.TreeItemCheckboxState.Unchecked };
+
+			(dirNode._children as any[]).push(file1, file2);
+
+			dirNode.updateCheckboxFromChildren();
+
+			assert.strictEqual(dirNode.checkboxState?.state, vscode.TreeItemCheckboxState.Unchecked);
+		});
+
+		it('propagates state through nested directories', function () {
+			const parentDir = new DirectoryTreeNode(createMockParent(), 'src');
+			const childDir = new DirectoryTreeNode(parentDir, 'utils');
+
+			const file1 = new MockFileNode(childDir);
+			file1.checkboxState = { state: vscode.TreeItemCheckboxState.Checked };
+
+			(childDir._children as any[]).push(file1);
+			parentDir._children.push(childDir);
+
+			// Update bottom-up (child first, then parent)
+			childDir.updateCheckboxFromChildren();
+			assert.strictEqual(childDir.checkboxState?.state, vscode.TreeItemCheckboxState.Checked);
+
+			parentDir.updateCheckboxFromChildren();
+			assert.strictEqual(parentDir.checkboxState?.state, vscode.TreeItemCheckboxState.Checked);
+		});
+
+		it('updates parent to Unchecked when a child is unchecked after being checked', function () {
+			const parentDir = new DirectoryTreeNode(createMockParent(), 'src');
+
+			const file1 = new MockFileNode(parentDir);
+			file1.checkboxState = { state: vscode.TreeItemCheckboxState.Checked };
+			const file2 = new MockFileNode(parentDir);
+			file2.checkboxState = { state: vscode.TreeItemCheckboxState.Checked };
+
+			(parentDir._children as any[]).push(file1, file2);
+
+			// All checked → parent should be Checked
+			parentDir.updateCheckboxFromChildren();
+			assert.strictEqual(parentDir.checkboxState?.state, vscode.TreeItemCheckboxState.Checked);
+
+			// Uncheck one file → parent should be Unchecked
+			file2.checkboxState = { state: vscode.TreeItemCheckboxState.Unchecked };
+			parentDir.updateCheckboxFromChildren();
+			assert.strictEqual(parentDir.checkboxState?.state, vscode.TreeItemCheckboxState.Unchecked);
+		});
+
+		it('updates correctly with mixed file and directory children', function () {
+			const rootDir = new DirectoryTreeNode(createMockParent(), 'root');
+			const subDir = new DirectoryTreeNode(rootDir, 'sub');
+
+			const subFile = new MockFileNode(subDir);
+			subFile.checkboxState = { state: vscode.TreeItemCheckboxState.Checked };
+			(subDir._children as any[]).push(subFile);
+
+			const rootFile = new MockFileNode(rootDir);
+			rootFile.checkboxState = { state: vscode.TreeItemCheckboxState.Checked };
+
+			(rootDir._children as any[]).push(subDir);
+			(rootDir._children as any[]).push(rootFile);
+
+			// Update bottom-up
+			subDir.updateCheckboxFromChildren();
+			rootDir.updateCheckboxFromChildren();
+			assert.strictEqual(rootDir.checkboxState?.state, vscode.TreeItemCheckboxState.Checked);
+
+			// Uncheck the sub-directory file
+			subFile.checkboxState = { state: vscode.TreeItemCheckboxState.Unchecked };
+			subDir.updateCheckboxFromChildren();
+			rootDir.updateCheckboxFromChildren();
+			assert.strictEqual(subDir.checkboxState?.state, vscode.TreeItemCheckboxState.Unchecked);
+			assert.strictEqual(rootDir.checkboxState?.state, vscode.TreeItemCheckboxState.Unchecked);
+		});
+	});
+});

src/view/treeNodes/directoryTreeNode.ts

@@ -131,12 +131,16 @@ export class DirectoryTreeNode extends TreeNode implements vscode.TreeItem {
 		return true;
 	}
 
-	private setCheckboxState(isChecked: boolean) {
+	public setCheckboxState(isChecked: boolean) {
 		this.checkboxState = isChecked ?
 			{ state: vscode.TreeItemCheckboxState.Checked, tooltip: vscode.l10n.t('Mark all files unviewed'), accessibilityInformation: { label: vscode.l10n.t('Mark all files in folder {0} as unviewed', this.label!) } } :
 			{ state: vscode.TreeItemCheckboxState.Unchecked, tooltip: vscode.l10n.t('Mark all files viewed'), accessibilityInformation: { label: vscode.l10n.t('Mark all files in folder {0} as viewed', this.label!) } };
 	}
 
+	public updateCheckboxFromChildren(): void {
+		this.setCheckboxState(this.allChildrenViewed());
+	}
+
 	getTreeItem(): vscode.TreeItem {
 		this.setCheckboxState(this.allChildrenViewed());
 		return this;

src/view/treeNodes/treeUtils.ts

@@ -46,9 +46,21 @@ export namespace TreeUtils {
 			}
 		}
 
+		// Eagerly update ancestor directory checkbox states from bottom to top.
+		// With manageCheckboxStateManually, we must set directory states before refresh
+		// rather than relying solely on getTreeItem(), since VS Code may not apply
+		// checkboxState changes returned from getTreeItem() during a refresh.
+		const allAffected = [...checkedNodes, ...uncheckedNodes];
+		for (const node of allAffected) {
+			let parent = node.getParent();
+			while (parent instanceof DirectoryTreeNode) {
+				parent.updateCheckboxFromChildren();
+				parent = parent.getParent();
+			}
+		}
+
 		// Refresh the tree so checkbox visual state updates.
 		// Refreshing the topmost affected directory will cascade to all descendants.
-		const allAffected = [...checkedNodes, ...uncheckedNodes];
 		const refreshedDirs = new Set<DirectoryTreeNode>();
 		for (const node of allAffected) {
 			let topDir: DirectoryTreeNode | undefined;