Fix #1729: Status bar cursor updates without requiring a tab switch

CodeEdit/Features/Editor/Models/Editor/Editor.swift

@@ -185,8 +185,11 @@ final class Editor: ObservableObject, Identifiable {
         let item = EditorInstance(workspace: workspace, file: file)
         // Item is already opened in a tab.
         guard !tabs.contains(item) || !asTemporary else {
-            selectedTab = item
-            addToHistory(item)
+            // Reuse the instance already in `tabs`. ``EditorInstance`` equality is by file, so a fresh
+            // instance would leave the editor and status bar observing different objects (#1729).
+            let existing = tabs.first(where: { $0.file == file }) ?? item
+            selectedTab = existing
+            addToHistory(existing)
             return
         }
 
@@ -203,7 +206,7 @@ final class Editor: ObservableObject, Identifiable {
             openTab(file: item.file)
         case (.none, true):
             openTab(file: item.file)
-            temporaryTab = item
+            temporaryTab = selectedTab
         case (.none, false):
             openTab(file: item.file)
         }
@@ -230,7 +233,7 @@ final class Editor: ObservableObject, Identifiable {
         } else {
             // If we couldn't find the current temporary tab (invalid state) we should still do *something*
             openTab(file: newItem.file)
-            temporaryTab = newItem
+            temporaryTab = selectedTab
         }
     }
 
@@ -240,6 +243,21 @@ final class Editor: ObservableObject, Identifiable {
     ///   - index: Index where the tab needs to be added. If nil, it is added to the back.
     ///   - fromHistory: Indicates whether the tab has been opened from going back in history.
     func openTab(file: CEWorkspaceFile, at index: Int? = nil, fromHistory: Bool = false) {
+        // Always select the instance that lives in `tabs` so cursor publishers stay shared with the editor view.
+        if let existing = tabs.first(where: { $0.file == file }) {
+            selectedTab = existing
+            if !fromHistory {
+                clearFuture()
+                addToHistory(existing)
+            }
+            do {
+                try openFile(item: existing)
+            } catch {
+                logger.error("Error opening file: \(error)")
+            }
+            return
+        }
+
         let item = Tab(workspace: workspace, file: file)
         if let index {
             tabs.insert(item, at: index)
@@ -251,13 +269,15 @@ final class Editor: ObservableObject, Identifiable {
             }
         }
 
-        selectedTab = item
+        // `tabs` may keep a previously inserted equal element; bind selection to that stored instance.
+        let stored = tabs.first(where: { $0.file == file }) ?? item
+        selectedTab = stored
         if !fromHistory {
             clearFuture()
-            addToHistory(item)
+            addToHistory(stored)
         }
         do {
-            try openFile(item: item)
+            try openFile(item: stored)
         } catch {
             logger.error("Error opening file: \(error)")
         }

CodeEdit/Features/Editor/Models/EditorInstance.swift

@@ -14,6 +14,8 @@ import CodeEditSourceEditor
 /// A single instance of an editor in a group with a published ``EditorInstance/cursorPositions`` variable to publish
 /// the user's current location in a file.
 class EditorInstance: ObservableObject, Hashable {
+    private static let defaultCursorPositions = [CursorPosition(line: 1, column: 1)]
+
     /// The file presented in this editor instance.
     let file: CEWorkspaceFile
 
@@ -43,9 +45,12 @@ class EditorInstance: ObservableObject, Hashable {
         replaceText = workspace?.searchState?.replaceText
         replaceTextSubject = PassthroughSubject()
 
-        self.cursorPositions = (
-            cursorPositions ?? editorState?.editorCursorPositions ?? [CursorPosition(line: 1, column: 1)]
-        )
+        // Prefer an explicit position, then a non-empty restored position, else a caret at 1:1.
+        // Empty restored arrays must not wipe the default — the status bar would show nothing.
+        let restoredCursorPositions = editorState?.editorCursorPositions
+        self.cursorPositions = cursorPositions
+            ?? (restoredCursorPositions?.isEmpty == false ? restoredCursorPositions : nil)
+            ?? Self.defaultCursorPositions
         self.scrollPosition = editorState?.scrollPosition
 
         // Setup listeners
@@ -124,6 +129,9 @@ class EditorInstance: ObservableObject, Hashable {
 
     /// Translates ranges (eg: from a cursor position) to other information like the number of lines in a range.
     class RangeTranslator: TextViewCoordinator {
+        /// Emits when the text view controller becomes visible so observers can refresh resolved cursor labels.
+        let controllerDidAppearSubject = PassthroughSubject<Void, Never>()
+
         private weak var textViewController: TextViewController?
 
         init() { }
@@ -136,6 +144,7 @@ class EditorInstance: ObservableObject, Hashable {
             if controller.isEditable && controller.isSelectable {
                 controller.view.window?.makeFirstResponder(controller.textView)
             }
+            controllerDidAppearSubject.send()
         }
 
         func destroy() {
@@ -158,6 +167,11 @@ class EditorInstance: ObservableObject, Hashable {
             return (endTextLine.index - startTextLine.index) + 1
         }
 
+        /// Resolves a cursor position through the text view when available; otherwise returns the input unchanged.
+        func resolveCursorPosition(_ cursorPosition: CursorPosition) -> CursorPosition {
+            textViewController?.resolveCursorPosition(cursorPosition) ?? cursorPosition
+        }
+
         func moveLinesUp() {
             guard let controller = textViewController else { return }
             controller.moveLinesUp()

CodeEdit/Features/Editor/Views/CodeFileView.swift

@@ -158,7 +158,11 @@ struct CodeFileView: View {
                     )
                 },
                 set: { newState in
-                    editorInstance.cursorPositions = newState.cursorPositions ?? []
+                    // Keep the last known caret when SourceEditor omits cursor state (e.g. scroll-only updates).
+                    // Writing `?? []` cleared the status bar until the next tab switch (#1729).
+                    if let cursorPositions = newState.cursorPositions {
+                        editorInstance.cursorPositions = cursorPositions
+                    }
                     editorInstance.scrollPosition = newState.scrollPosition
                     editorInstance.findText = newState.findText
                     editorInstance.findTextSubject.send(newState.findText)

CodeEdit/Features/StatusBar/Views/StatusBarItems/StatusBarCursorPositionLabel.swift

@@ -23,7 +23,9 @@ struct StatusBarCursorPositionLabel: View {
     var body: some View {
         Group {
             if let currentTab = tab {
+                // Identity by object, not file equality — ``EditorInstance`` compares equal by file.
                 LineLabel(editorInstance: currentTab)
+                    .id(ObjectIdentifier(currentTab))
             } else {
                 Text("").accessibilityLabel("No Selection")
             }
@@ -38,6 +40,65 @@ struct StatusBarCursorPositionLabel: View {
         .onReceive(editorManager.tabBarTabIdSubject) { _ in
             updateSource()
         }
+        .onReceive(editorManager.$activeEditor) { _ in
+            updateSource()
+        }
+        .onChange(of: editorManager.activeEditor.selectedTab) { _, newTab in
+            tab = newTab
+        }
+    }
+
+    /// Formats the status-bar cursor label from cursor positions.
+    ///
+    /// Extracted for unit testing. When line/column are unresolved (`<= 0`), falls back to a safe
+    /// `Line: 1  Col: 1` caret label (or character offset when Option is held).
+    static func formatLabel(
+        cursorPositions: [CursorPosition],
+        optionKeyPressed: Bool,
+        linesInRange: (NSRange) -> Int
+    ) -> String {
+        if cursorPositions.isEmpty {
+            return ""
+        }
+
+        // More than one selection, display the number of selections.
+        if cursorPositions.count > 1 {
+            return "\(cursorPositions.count) selected ranges"
+        }
+
+        let position = cursorPositions[0]
+
+        // If the selection is more than just a cursor, return the length.
+        if position.range.length > 0 {
+            // When the option key is pressed display the character range.
+            if optionKeyPressed {
+                return "Char: \(position.range.location) Len: \(position.range.length)"
+            }
+
+            let lineCount = linesInRange(position.range)
+
+            if lineCount > 1 {
+                return "\(lineCount) lines"
+            }
+
+            return "\(position.range.length) characters"
+        }
+
+        // When the option key is pressed display the character offset.
+        if optionKeyPressed {
+            if position.range != .notFound {
+                return "Char: \(position.range.location) Len: 0"
+            }
+            return "Char: 0 Len: 0"
+        }
+
+        // Unresolved line/column (range-only positions from SourceEditor) until the controller fills them in.
+        if position.start.line <= 0 || position.start.column <= 0 {
+            return "Line: 1  Col: 1"
+        }
+
+        // When there's a single cursor, display the line and column.
+        return "Line: \(position.start.line)  Col: \(position.start.column)"
     }
 
     struct LineLabel: View {
@@ -50,20 +111,29 @@ struct StatusBarCursorPositionLabel: View {
 
         let editorInstance: EditorInstance
 
-        @State private var cursorPositions: [CursorPosition] = []
+        @State private var cursorPositions: [CursorPosition]
 
         init(editorInstance: EditorInstance) {
             self.editorInstance = editorInstance
+            self._cursorPositions = State(initialValue: editorInstance.cursorPositions)
         }
 
         var body: some View {
             Text(getLabel())
                 .font(statusBarViewModel.statusBarFont)
                 .foregroundColor(foregroundColor)
                 .lineLimit(1)
+                .onAppear {
+                    cursorPositions = editorInstance.cursorPositions
+                }
                 .onReceive(editorInstance.$cursorPositions) { newValue in
                     self.cursorPositions = newValue
                 }
+                .onReceive(editorInstance.rangeTranslator.controllerDidAppearSubject) { _ in
+                    self.cursorPositions = editorInstance.cursorPositions.map {
+                        editorInstance.rangeTranslator.resolveCursorPosition($0)
+                    }
+                }
         }
 
         private var foregroundColor: Color {
@@ -84,38 +154,12 @@ struct StatusBarCursorPositionLabel: View {
         /// Create a label string for cursor positions.
         /// - Returns: A string describing the user's location in a document.
         func getLabel() -> String {
-            if cursorPositions.isEmpty {
-                return ""
-            }
-
-            // More than one selection, display the number of selections.
-            if cursorPositions.count > 1 {
-                return "\(cursorPositions.count) selected ranges"
-            }
-
-            // If the selection is more than just a cursor, return the length.
-            if cursorPositions[0].range.length > 0 {
-                // When the option key is pressed display the character range.
-                if modifierKeys.contains(.option) {
-                    return "Char: \(cursorPositions[0].range.location) Len: \(cursorPositions[0].range.length)"
-                }
-
-                let lineCount = getLines(cursorPositions[0].range)
-
-                if lineCount > 1 {
-                    return "\(lineCount) lines"
-                }
-
-                return "\(cursorPositions[0].range.length) characters"
-            }
-
-            // When the option key is pressed display the character offset.
-            if modifierKeys.contains(.option) {
-                return "Char: \(cursorPositions[0].range.location) Len: 0"
-            }
-
-            // When there's a single cursor, display the line and column.
-            return "Line: \(cursorPositions[0].start.line)  Col: \(cursorPositions[0].start.column)"
+            let resolved = cursorPositions.map { editorInstance.rangeTranslator.resolveCursorPosition($0) }
+            return StatusBarCursorPositionLabel.formatLabel(
+                cursorPositions: resolved,
+                optionKeyPressed: modifierKeys.contains(.option),
+                linesInRange: getLines
+            )
         }
     }
 }

CodeEditTests/Features/Editor/EditorTabReuseTests.swift

@@ -0,0 +1,63 @@
+//
+//  EditorTabReuseTests.swift
+//  CodeEditTests
+//
+//  Created by Boris Serzhanovich on 1/8/26.
+//
+
+import Testing
+import Foundation
+import OrderedCollections
+import CodeEditSourceEditor
+@testable import CodeEdit
+
+@Suite("Editor tab instance reuse")
+struct EditorTabReuseTests {
+
+    @Test
+    @MainActor
+    func reopeningSameFileReusesEditorInstance() throws {
+        try withTempDir { dir in
+            let fileURL = dir.appending(path: "Sample.swift")
+            try "print(1)\n".write(to: fileURL, atomically: true, encoding: .utf8)
+            let file = CEWorkspaceFile(url: fileURL)
+
+            // Disambiguate overloaded `Editor` inits (`OrderedSet<CEWorkspaceFile>` vs `OrderedSet<Tab>`).
+            let editor = Editor(files: OrderedSet<CEWorkspaceFile>(), workspace: nil)
+            editor.openTab(file: file)
+
+            let firstInstance = try #require(editor.selectedTab)
+            firstInstance.cursorPositions = [CursorPosition(line: 3, column: 2)]
+
+            // Re-open the same file (as the navigator / history paths do).
+            editor.openTab(file: file)
+
+            let secondInstance = try #require(editor.selectedTab)
+            #expect(ObjectIdentifier(firstInstance) == ObjectIdentifier(secondInstance))
+            #expect(secondInstance.cursorPositions.first?.start.line == 3)
+            #expect(editor.tabs.count == 1)
+        }
+    }
+
+    @Test
+    @MainActor
+    func temporaryReopenReusesExistingInstance() throws {
+        try withTempDir { dir in
+            let fileURL = dir.appending(path: "Temp.swift")
+            try "let x = 1\n".write(to: fileURL, atomically: true, encoding: .utf8)
+            let file = CEWorkspaceFile(url: fileURL)
+
+            let editor = Editor(files: OrderedSet<CEWorkspaceFile>(), workspace: nil)
+            editor.openTab(file: file, asTemporary: true)
+
+            let firstInstance = try #require(editor.selectedTab)
+            firstInstance.cursorPositions = [CursorPosition(line: 1, column: 5)]
+
+            editor.openTab(file: file, asTemporary: true)
+
+            let secondInstance = try #require(editor.selectedTab)
+            #expect(ObjectIdentifier(firstInstance) == ObjectIdentifier(secondInstance))
+            #expect(secondInstance.cursorPositions.first?.start.column == 5)
+        }
+    }
+}