debugger: Fix typing in active buffer resulting a jump to an active debug line (#27439)

/cc @iamnbutler 

Release Notes:

- N/A

---------

Co-authored-by: Anthony Eid <hello@anthonyeid.me>

crates/editor/src/editor.rs

@@ -12644,15 +12644,14 @@ impl Editor {
         let start = snapshot.buffer_snapshot.anchor_before(start);
         let end = snapshot.buffer_snapshot.anchor_before(end);
 
-        self.clear_row_highlights::<T>();
         self.highlight_rows::<T>(
             start..end,
             highlight_color
                 .unwrap_or_else(|| cx.theme().colors().editor_highlighted_line_background),
-            true,
+            false,
             cx,
         );
-        self.request_autoscroll(Autoscroll::center(), cx);
+        self.request_autoscroll(Autoscroll::center().for_anchor(start), cx);
     }
 
     pub fn go_to_definition(

crates/editor/src/scroll/autoscroll.rs

@@ -3,54 +3,66 @@ use crate::{
 };
 use gpui::{px, Bounds, Context, Pixels, Window};
 use language::Point;
+use multi_buffer::Anchor;
 use std::{cmp, f32};
 
 #[derive(PartialEq, Eq, Clone, Copy)]
 pub enum Autoscroll {
     Next,
-    Strategy(AutoscrollStrategy),
+    Strategy(AutoscrollStrategy, Option<Anchor>),
 }
 
 impl Autoscroll {
     /// scrolls the minimal amount to (try) and fit all cursors onscreen
     pub fn fit() -> Self {
-        Self::Strategy(AutoscrollStrategy::Fit)
+        Self::Strategy(AutoscrollStrategy::Fit, None)
     }
 
     /// scrolls the minimal amount to fit the newest cursor
     pub fn newest() -> Self {
-        Self::Strategy(AutoscrollStrategy::Newest)
+        Self::Strategy(AutoscrollStrategy::Newest, None)
     }
 
     /// scrolls so the newest cursor is vertically centered
     pub fn center() -> Self {
-        Self::Strategy(AutoscrollStrategy::Center)
+        Self::Strategy(AutoscrollStrategy::Center, None)
     }
 
     /// scrolls so the newest cursor is near the top
     /// (offset by vertical_scroll_margin)
     pub fn focused() -> Self {
-        Self::Strategy(AutoscrollStrategy::Focused)
+        Self::Strategy(AutoscrollStrategy::Focused, None)
     }
 
     /// Scrolls so that the newest cursor is roughly an n-th line from the top.
     pub fn top_relative(n: usize) -> Self {
-        Self::Strategy(AutoscrollStrategy::TopRelative(n))
+        Self::Strategy(AutoscrollStrategy::TopRelative(n), None)
     }
 
     /// Scrolls so that the newest cursor is at the top.
     pub fn top() -> Self {
-        Self::Strategy(AutoscrollStrategy::Top)
+        Self::Strategy(AutoscrollStrategy::Top, None)
     }
 
     /// Scrolls so that the newest cursor is roughly an n-th line from the bottom.
     pub fn bottom_relative(n: usize) -> Self {
-        Self::Strategy(AutoscrollStrategy::BottomRelative(n))
+        Self::Strategy(AutoscrollStrategy::BottomRelative(n), None)
     }
 
     /// Scrolls so that the newest cursor is at the bottom.
     pub fn bottom() -> Self {
-        Self::Strategy(AutoscrollStrategy::Bottom)
+        Self::Strategy(AutoscrollStrategy::Bottom, None)
+    }
+
+    /// Applies a given auto-scroll strategy to a given anchor instead of a cursor.
+    /// E.G: Autoscroll::center().for_anchor(...) results in the anchor being at the center of the screen.
+    pub fn for_anchor(self, anchor: Anchor) -> Self {
+        match self {
+            Autoscroll::Next => self,
+            Autoscroll::Strategy(autoscroll_strategy, _) => {
+                Self::Strategy(autoscroll_strategy, Some(anchor))
+            }
+        }
     }
 }
 
@@ -142,8 +154,11 @@ impl Editor {
                 .as_f32();
 
             let selections_fit = target_bottom - target_top <= visible_lines;
-            if autoscroll == Autoscroll::newest()
-                || (autoscroll == Autoscroll::fit() && !selections_fit)
+            if matches!(
+                autoscroll,
+                Autoscroll::Strategy(AutoscrollStrategy::Newest, _)
+            ) || (matches!(autoscroll, Autoscroll::Strategy(AutoscrollStrategy::Fit, _))
+                && !selections_fit)
             {
                 let newest_selection_top = selections
                     .iter()
@@ -165,7 +180,7 @@ impl Editor {
         };
 
         let strategy = match autoscroll {
-            Autoscroll::Strategy(strategy) => strategy,
+            Autoscroll::Strategy(strategy, _) => strategy,
             Autoscroll::Next => {
                 let last_autoscroll = &self.scroll_manager.last_autoscroll;
                 if let Some(last_autoscroll) = last_autoscroll {
@@ -182,6 +197,10 @@ impl Editor {
                 }
             }
         };
+        if let Autoscroll::Strategy(_, Some(anchor)) = autoscroll {
+            target_top = anchor.to_display_point(&display_map).row().as_f32();
+            target_bottom = target_top + 1.;
+        }
 
         match strategy {
             AutoscrollStrategy::Fit | AutoscrollStrategy::Newest => {