Fix: Preserve view and pin preview tabs on :w

- Use Tab API when available to detect preview tabs and only call showTextDocument when needed.
- Ensure saving in compare/diff editors does not switch to a normal editor (fixes #9800, #9796).
- Keep previous behavior of pinning preview tabs on :w so :w matches Cmd+S (fixes #9697).
- Add test coverage for write, including new doc handling logic

references PR #9698
fixes #9800, fixes #9796, fixes #9697

Author: McCleese, James

src/cmd_line/commands/write.ts

@@ -135,7 +135,10 @@ export class WriteCommand extends ExCommand {
   }
 
   private async save(vimState: VimState): Promise<void> {
-    await vscode.window.showTextDocument(vimState.document, { preview: false });
+    if (this.shouldShowDocument(vimState.document.uri)) {
+      await vscode.window.showTextDocument(vimState.document, { preview: false });
+    }
+
     await this.background(
       vimState.document.save().then((success) => {
         if (success) {
@@ -153,6 +156,40 @@ export class WriteCommand extends ExCommand {
     );
   }
 
+  /**
+   * Determines whether to call showTextDocument when saving.
+   * Avoids disrupting diff views and handles preview tab pinning.
+   */
+  private shouldShowDocument(documentUri: vscode.Uri): boolean {
+    const uriString = documentUri.toString();
+    const matchingTab = vscode.window.tabGroups.activeTabGroup.tabs.find((tab: vscode.Tab) =>
+      this.tabContainsDocument(tab, uriString),
+    );
+
+    if (matchingTab) {
+      return matchingTab.isPreview;
+    }
+
+    // No matching tab found, show it
+    return true;
+  }
+
+  /**
+   * Check if a tab contains the specified document URI.
+   * Handles regular tabs and diff tabs.
+   */
+  private tabContainsDocument(tab: vscode.Tab, uriString: string): boolean {
+    const input = tab.input as
+      | { uri?: vscode.Uri; original?: vscode.Uri; modified?: vscode.Uri }
+      | undefined;
+
+    return (
+      input?.uri?.toString() === uriString ||
+      input?.original?.toString() === uriString ||
+      input?.modified?.toString() === uriString
+    );
+  }
+
   private async background<T>(fn: Thenable<T>): Promise<void> {
     if (!this.arguments.bgWrite) {
       await fn;

test/cmd_line/write.test.ts

@@ -0,0 +1,204 @@
+import * as assert from 'assert';
+import * as sinon from 'sinon';
+import * as vscode from 'vscode';
+
+import { getAndUpdateModeHandler } from '../../extension';
+import { ExCommandLine } from '../../src/cmd_line/commandLine';
+import { ModeHandler } from '../../src/mode/modeHandler';
+import { assertEqualLines, cleanUpWorkspace, setupWorkspace } from '../testUtils';
+
+suite('Write command (:w)', () => {
+  let modeHandler: ModeHandler;
+
+  setup(async () => {
+    await setupWorkspace();
+    modeHandler = (await getAndUpdateModeHandler())!;
+  });
+
+  teardown(cleanUpWorkspace);
+
+  /**
+   * Helper to type "hello world!" in insert mode
+   */
+  const typeHelloWorld = async () => {
+    await modeHandler.handleMultipleKeyEvents([
+      'i',
+      'h',
+      'e',
+      'l',
+      'l',
+      'o',
+      ' ',
+      'w',
+      'o',
+      'r',
+      'l',
+      'd',
+      '!',
+      '<Esc>',
+    ]);
+  };
+
+  /**
+   * Helper to run the :w command
+   */
+  const runWriteCommand = async () => {
+    await new ExCommandLine('w', modeHandler.vimState.currentMode).run(modeHandler.vimState);
+  };
+
+  suite('Basic functionality', () => {
+    test('write (:w) - basic functionality', async () => {
+      await typeHelloWorld();
+      await runWriteCommand();
+
+      assertEqualLines(['hello world!']);
+    });
+
+    test('write (:w) - should save document', async () => {
+      await modeHandler.handleMultipleKeyEvents([
+        'i',
+        't',
+        'e',
+        's',
+        't',
+        ' ',
+        'c',
+        'o',
+        'n',
+        't',
+        'e',
+        'n',
+        't',
+        '<Esc>',
+      ]);
+
+      await new ExCommandLine('w', modeHandler.vimState.currentMode).run(modeHandler.vimState);
+
+      assertEqualLines(['test content']);
+    });
+  });
+  suite('Tab Groups API - diff view preservation', () => {
+    let showTextDocumentStub: sinon.SinonStub;
+    let tabGroupsStub: sinon.SinonStub;
+
+    setup(() => {
+      showTextDocumentStub = sinon.stub(vscode.window, 'showTextDocument').resolves();
+      tabGroupsStub = sinon.stub(vscode.window, 'tabGroups');
+    });
+
+    teardown(() => {
+      showTextDocumentStub.restore();
+      tabGroupsStub.restore();
+    });
+
+    test('should pin preview tabs when saving', async () => {
+      const docUri = modeHandler.vimState.document.uri.toString();
+      const mockTab = {
+        isPreview: true,
+        input: { uri: { toString: () => docUri } },
+      };
+      tabGroupsStub.get(() => ({ activeTabGroup: { tabs: [mockTab] } }));
+
+      await typeHelloWorld();
+      await runWriteCommand();
+
+      assert.strictEqual(
+        showTextDocumentStub.calledOnce,
+        true,
+        'showTextDocument should be called to pin preview tabs',
+      );
+    });
+
+    test('should preserve diff view for non-preview tabs', async () => {
+      const docUri = modeHandler.vimState.document.uri.toString();
+      const mockTab = {
+        isPreview: false,
+        input: { uri: { toString: () => docUri } },
+      };
+      tabGroupsStub.get(() => ({ activeTabGroup: { tabs: [mockTab] } }));
+
+      await typeHelloWorld();
+      await runWriteCommand();
+
+      assert.strictEqual(
+        showTextDocumentStub.called,
+        false,
+        'showTextDocument should not be called for non-preview tabs',
+      );
+    });
+
+    test('should handle diff tabs correctly (original side)', async () => {
+      const docUri = modeHandler.vimState.document.uri.toString();
+      const mockDiffTab = {
+        isPreview: false,
+        input: {
+          original: { toString: () => docUri },
+          modified: { toString: () => 'other-file-uri' },
+        },
+      };
+      tabGroupsStub.get(() => ({ activeTabGroup: { tabs: [mockDiffTab] } }));
+
+      await typeHelloWorld();
+      await runWriteCommand();
+
+      assert.strictEqual(
+        showTextDocumentStub.called,
+        false,
+        'should not disrupt diff view when document is original side',
+      );
+    });
+
+    test('should handle diff tabs correctly (modified side)', async () => {
+      const docUri = modeHandler.vimState.document.uri.toString();
+      const mockDiffTab = {
+        isPreview: false,
+        input: {
+          original: { toString: () => 'other-file-uri' },
+          modified: { toString: () => docUri },
+        },
+      };
+      tabGroupsStub.get(() => ({ activeTabGroup: { tabs: [mockDiffTab] } }));
+
+      await typeHelloWorld();
+      await runWriteCommand();
+
+      assert.strictEqual(
+        showTextDocumentStub.called,
+        false,
+        'should not disrupt diff view when document is modified side',
+      );
+    });
+
+    test('should call showTextDocument when document not in active tab group', async () => {
+      tabGroupsStub.get(() => ({ activeTabGroup: { tabs: [] } }));
+
+      await typeHelloWorld();
+      await runWriteCommand();
+
+      assert.strictEqual(
+        showTextDocumentStub.calledOnce,
+        true,
+        'showTextDocument should be called when document not in active tab group',
+      );
+    });
+
+    test('should only check active tab group, not other tab groups', async () => {
+      const docUri = modeHandler.vimState.document.uri.toString();
+      // Active tab group has a different file
+      tabGroupsStub.get(() => ({
+        activeTabGroup: {
+          tabs: [{ isPreview: false, input: { uri: { toString: () => 'other-file' } } }],
+        },
+      }));
+
+      await typeHelloWorld();
+      await runWriteCommand();
+
+      assert.strictEqual(
+        showTextDocumentStub.calledOnce,
+        true,
+        'should call showTextDocument when document not in active tab group',
+      );
+    });
+  });
+});