block_map: Consolidate all companion-related refs into a single CompanionView (#48223)

Release Notes:

- N/A

--

I think it's possible to clean this up further but will withhold until
we land bits necessary to correctly align split view in presence of
custom blocks.

crates/editor/src/display_map.rs

@@ -81,8 +81,8 @@ mod wrap_map;
 pub use crate::display_map::{fold_map::FoldMap, inlay_map::InlayMap, tab_map::TabMap};
 pub use block_map::{
     Block, BlockChunks as DisplayChunks, BlockContext, BlockId, BlockMap, BlockPlacement,
-    BlockPoint, BlockProperties, BlockRows, BlockStyle, CustomBlockId, EditorMargins, RenderBlock,
-    StickyHeaderExcerpt,
+    BlockPoint, BlockProperties, BlockRows, BlockStyle, CompanionView, CustomBlockId,
+    EditorMargins, RenderBlock, StickyHeaderExcerpt,
 };
 pub use crease_map::*;
 pub use fold_map::{
@@ -357,7 +357,7 @@ impl DisplayMap {
                 old: WrapRow(0)..snapshot.max_point().row(),
                 new: WrapRow(0)..snapshot.max_point().row(),
             }]);
-            self.block_map.read(snapshot, edits, None, None);
+            self.block_map.read(snapshot, edits, None);
             return;
         };
 
@@ -381,11 +381,14 @@ impl DisplayMap {
         let companion_wrap_data = companion_display_map
             .update(cx, |dm, cx| dm.sync_through_wrap(cx))
             .ok();
-
-        let companion_wrap_edits = companion_wrap_data
-            .as_ref()
-            .map(|(snapshot, edits)| (snapshot, edits));
         let companion = self.companion.as_ref().map(|(_, c)| c.read(cx));
+        let companion_view =
+            companion_wrap_data
+                .as_ref()
+                .zip(companion)
+                .map(|((snapshot, edits), companion)| {
+                    CompanionView::new(self.entity_id, snapshot, edits, companion)
+                });
 
         let edits = Patch::new(
             [text::Edit {
@@ -395,12 +398,8 @@ impl DisplayMap {
             .into_iter()
             .collect(),
         );
-        self.block_map.read(
-            snapshot.clone(),
-            edits.clone(),
-            companion_wrap_edits,
-            companion.map(|c| (c, self.entity_id)),
-        );
+        self.block_map
+            .read(snapshot.clone(), edits.clone(), companion_view);
 
         if let Some((companion_dm, _)) = &self.companion {
             let _ = companion_dm.update(cx, |dm, _cx| {
@@ -409,8 +408,8 @@ impl DisplayMap {
                     dm.block_map.read(
                         companion_snapshot,
                         companion_edits,
-                        Some((&snapshot, &edits)),
-                        their_companion_ref.map(|c| (c, dm.entity_id)),
+                        their_companion_ref
+                            .map(|c| CompanionView::new(dm.entity_id, &snapshot, &edits, c)),
                     );
                 }
             });
@@ -453,19 +452,19 @@ impl DisplayMap {
                 .update(cx, |dm, cx| dm.sync_through_wrap(cx))
                 .ok()
         });
-
-        let companion_wrap_edits = companion_wrap_data
-            .as_ref()
-            .map(|(snapshot, edits)| (snapshot, edits));
         let companion_ref = self.companion.as_ref().map(|(_, c)| c.read(cx));
+        let companion_view = companion_wrap_data.as_ref().zip(companion_ref).map(
+            |((snapshot, edits), companion)| {
+                CompanionView::new(self.entity_id, snapshot, edits, companion)
+            },
+        );
 
         let block_snapshot = self
             .block_map
             .read(
                 self_wrap_snapshot.clone(),
                 self_wrap_edits.clone(),
-                companion_wrap_edits,
-                companion_ref.map(|c| (c, self.entity_id)),
+                companion_view,
             )
             .snapshot;
 
@@ -476,8 +475,14 @@ impl DisplayMap {
                     dm.block_map.read(
                         companion_snapshot,
                         companion_edits,
-                        Some((&self_wrap_snapshot, &self_wrap_edits)),
-                        their_companion_ref.map(|c| (c, dm.entity_id)),
+                        their_companion_ref.map(|c| {
+                            CompanionView::new(
+                                dm.entity_id,
+                                &self_wrap_snapshot,
+                                &self_wrap_edits,
+                                c,
+                            )
+                        }),
                     );
                 }
             });
@@ -508,7 +513,7 @@ impl DisplayMap {
 
         let block_snapshot = self
             .block_map
-            .read(wrap_snapshot, wrap_edits, None, None)
+            .read(wrap_snapshot, wrap_edits, None)
             .snapshot;
 
         DisplaySnapshot {
@@ -558,10 +563,6 @@ impl DisplayMap {
                 .ok()
         });
 
-        let companion_wrap_edits = companion_wrap_data
-            .as_ref()
-            .map(|(snapshot, edits)| (snapshot, edits));
-
         let (snapshot, edits) = self.inlay_map.sync(buffer_snapshot.clone(), edits);
         let (mut fold_map, snapshot, edits) = self.fold_map.write(snapshot, edits);
         let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
@@ -569,13 +570,15 @@ impl DisplayMap {
             .wrap_map
             .update(cx, |map, cx| map.sync(snapshot, edits, cx));
 
-        let companion_ref = self.companion.as_ref().map(|(_, c)| c.read(cx));
-        self.block_map.read(
-            snapshot,
-            edits,
-            companion_wrap_edits,
-            companion_ref.map(|c| (c, self.entity_id)),
-        );
+        {
+            let companion_ref = self.companion.as_ref().map(|(_, c)| c.read(cx));
+            let companion_view = companion_wrap_data.as_ref().zip(companion_ref).map(
+                |((snapshot, edits), companion)| {
+                    CompanionView::new(self.entity_id, snapshot, edits, companion)
+                },
+            );
+            self.block_map.read(snapshot, edits, companion_view);
+        }
 
         let inline = creases.iter().filter_map(|crease| {
             if let Crease::Inline {
@@ -597,17 +600,16 @@ impl DisplayMap {
         let (self_wrap_snapshot, self_wrap_edits) =
             (self_new_wrap_snapshot.clone(), self_new_wrap_edits.clone());
 
-        let companion_wrap_edits = companion_wrap_data
-            .as_ref()
-            .map(|(snapshot, edits)| (snapshot, edits));
-        let companion_ref = self.companion.as_ref().map(|(_, c)| c.read(cx));
-
-        let mut block_map = self.block_map.write(
-            self_new_wrap_snapshot,
-            self_new_wrap_edits,
-            companion_wrap_edits,
-            companion_ref.map(|c| (c, self.entity_id)),
-        );
+        let mut block_map = {
+            let companion_ref = self.companion.as_ref().map(|(_, c)| c.read(cx));
+            let companion_view = companion_wrap_data.as_ref().zip(companion_ref).map(
+                |((snapshot, edits), companion)| {
+                    CompanionView::new(self.entity_id, snapshot, edits, companion)
+                },
+            );
+            self.block_map
+                .write(self_new_wrap_snapshot, self_new_wrap_edits, companion_view)
+        };
         let blocks = creases.into_iter().filter_map(|crease| {
             if let Crease::Block {
                 range,
@@ -652,8 +654,14 @@ impl DisplayMap {
                     dm.block_map.read(
                         companion_snapshot,
                         companion_edits,
-                        Some((&self_wrap_snapshot, &self_wrap_edits)),
-                        their_companion_ref.map(|c| (c, dm.entity_id)),
+                        their_companion_ref.map(|c| {
+                            CompanionView::new(
+                                dm.entity_id,
+                                &self_wrap_snapshot,
+                                &self_wrap_edits,
+                                c,
+                            )
+                        }),
                     );
                 }
             });
@@ -678,10 +686,6 @@ impl DisplayMap {
                 .ok()
         });
 
-        let companion_wrap_edits = companion_wrap_data
-            .as_ref()
-            .map(|(snapshot, edits)| (snapshot, edits));
-
         let (snapshot, edits) = self.inlay_map.sync(snapshot, edits);
         let (mut fold_map, snapshot, edits) = self.fold_map.write(snapshot, edits);
         let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
@@ -689,13 +693,15 @@ impl DisplayMap {
             .wrap_map
             .update(cx, |map, cx| map.sync(snapshot, edits, cx));
 
-        let companion_ref = self.companion.as_ref().map(|(_, c)| c.read(cx));
-        self.block_map.read(
-            snapshot,
-            edits,
-            companion_wrap_edits,
-            companion_ref.map(|c| (c, self.entity_id)),
-        );
+        {
+            let companion_ref = self.companion.as_ref().map(|(_, c)| c.read(cx));
+            let companion_view = companion_wrap_data.as_ref().zip(companion_ref).map(
+                |((snapshot, edits), companion)| {
+                    CompanionView::new(self.entity_id, snapshot, edits, companion)
+                },
+            );
+            self.block_map.read(snapshot, edits, companion_view);
+        }
 
         let (snapshot, edits) = fold_map.remove_folds(ranges, type_id);
         let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
@@ -706,17 +712,16 @@ impl DisplayMap {
         let (self_wrap_snapshot, self_wrap_edits) =
             (self_new_wrap_snapshot.clone(), self_new_wrap_edits.clone());
 
-        let companion_wrap_edits = companion_wrap_data
-            .as_ref()
-            .map(|(snapshot, edits)| (snapshot, edits));
-        let companion_ref = self.companion.as_ref().map(|(_, c)| c.read(cx));
-
-        self.block_map.write(
-            self_new_wrap_snapshot,
-            self_new_wrap_edits,
-            companion_wrap_edits,
-            companion_ref.map(|c| (c, self.entity_id)),
-        );
+        {
+            let companion_ref = self.companion.as_ref().map(|(_, c)| c.read(cx));
+            let companion_view = companion_wrap_data.as_ref().zip(companion_ref).map(
+                |((snapshot, edits), companion)| {
+                    CompanionView::new(self.entity_id, snapshot, edits, companion)
+                },
+            );
+            self.block_map
+                .write(self_new_wrap_snapshot, self_new_wrap_edits, companion_view);
+        }
 
         if let Some((companion_dm, _)) = &self.companion {
             let _ = companion_dm.update(cx, |dm, cx| {
@@ -725,8 +730,14 @@ impl DisplayMap {
                     dm.block_map.read(
                         companion_snapshot,
                         companion_edits,
-                        Some((&self_wrap_snapshot, &self_wrap_edits)),
-                        their_companion_ref.map(|c| (c, dm.entity_id)),
+                        their_companion_ref.map(|c| {
+                            CompanionView::new(
+                                dm.entity_id,
+                                &self_wrap_snapshot,
+                                &self_wrap_edits,
+                                c,
+                            )
+                        }),
                     );
                 }
             });
@@ -755,10 +766,6 @@ impl DisplayMap {
                 .ok()
         });
 
-        let companion_wrap_edits = companion_wrap_data
-            .as_ref()
-            .map(|(snapshot, edits)| (snapshot, edits));
-
         let (snapshot, edits) = self.inlay_map.sync(snapshot, edits);
         let (mut fold_map, snapshot, edits) = self.fold_map.write(snapshot, edits);
         let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
@@ -766,13 +773,15 @@ impl DisplayMap {
             .wrap_map
             .update(cx, |map, cx| map.sync(snapshot, edits, cx));
 
-        let companion_ref = self.companion.as_ref().map(|(_, c)| c.read(cx));
-        self.block_map.read(
-            snapshot,
-            edits,
-            companion_wrap_edits,
-            companion_ref.map(|c| (c, self.entity_id)),
-        );
+        {
+            let companion_ref = self.companion.as_ref().map(|(_, c)| c.read(cx));
+            let companion_view = companion_wrap_data.as_ref().zip(companion_ref).map(
+                |((snapshot, edits), companion)| {
+                    CompanionView::new(self.entity_id, snapshot, edits, companion)
+                },
+            );
+            self.block_map.read(snapshot, edits, companion_view);
+        }
 
         let (snapshot, edits) =
             fold_map.unfold_intersecting(offset_ranges.iter().cloned(), inclusive);
@@ -784,17 +793,19 @@ impl DisplayMap {
         let (self_wrap_snapshot, self_wrap_edits) =
             (self_new_wrap_snapshot.clone(), self_new_wrap_edits.clone());
 
-        let companion_wrap_edits = companion_wrap_data
-            .as_ref()
-            .map(|(snapshot, edits)| (snapshot, edits));
-        let companion_ref = self.companion.as_ref().map(|(_, c)| c.read(cx));
-
-        let mut block_map = self.block_map.write(
-            self_new_wrap_snapshot.clone(),
-            self_new_wrap_edits,
-            companion_wrap_edits,
-            companion_ref.map(|c| (c, self.entity_id)),
-        );
+        let mut block_map = {
+            let companion_ref = self.companion.as_ref().map(|(_, c)| c.read(cx));
+            let companion_view = companion_wrap_data.as_ref().zip(companion_ref).map(
+                |((snapshot, edits), companion)| {
+                    CompanionView::new(self.entity_id, snapshot, edits, companion)
+                },
+            );
+            self.block_map.write(
+                self_new_wrap_snapshot.clone(),
+                self_new_wrap_edits,
+                companion_view,
+            )
+        };
         block_map.remove_intersecting_replace_blocks(offset_ranges, inclusive);
 
         if let Some((companion_dm, _)) = &self.companion {
@@ -804,8 +815,14 @@ impl DisplayMap {
                     dm.block_map.read(
                         companion_snapshot,
                         companion_edits,
-                        Some((&self_wrap_snapshot, &self_wrap_edits)),
-                        their_companion_ref.map(|c| (c, dm.entity_id)),
+                        their_companion_ref.map(|c| {
+                            CompanionView::new(
+                                dm.entity_id,
+                                &self_wrap_snapshot,
+                                &self_wrap_edits,
+                                c,
+                            )
+                        }),
                     );
                 }
             });
@@ -824,16 +841,17 @@ impl DisplayMap {
                 .ok()
         });
 
-        let companion_wrap_edits = companion_wrap_data
-            .as_ref()
-            .map(|(snapshot, edits)| (snapshot, edits));
         let companion_ref = self.companion.as_ref().map(|(_, c)| c.read(cx));
+        let companion_view = companion_wrap_data.as_ref().zip(companion_ref).map(
+            |((snapshot, edits), companion)| {
+                CompanionView::new(self.entity_id, snapshot, edits, companion)
+            },
+        );
 
         let mut block_map = self.block_map.write(
             self_wrap_snapshot.clone(),
             self_wrap_edits.clone(),
-            companion_wrap_edits,
-            companion_ref.map(|c| (c, self.entity_id)),
+            companion_view,
         );
         block_map.disable_header_for_buffer(buffer_id);
 
@@ -844,8 +862,14 @@ impl DisplayMap {
                     dm.block_map.read(
                         companion_snapshot,
                         companion_edits,
-                        Some((&self_wrap_snapshot, &self_wrap_edits)),
-                        their_companion_ref.map(|c| (c, dm.entity_id)),
+                        their_companion_ref.map(|c| {
+                            CompanionView::new(
+                                dm.entity_id,
+                                &self_wrap_snapshot,
+                                &self_wrap_edits,
+                                c,
+                            )
+                        }),
                     );
                 }
             });
@@ -883,16 +907,17 @@ impl DisplayMap {
                 .ok()
         });
 
-        let companion_wrap_edits = companion_wrap_data
-            .as_ref()
-            .map(|(snapshot, edits)| (snapshot, edits));
         let companion_ref = self.companion.as_ref().map(|(_, c)| c.read(cx));
+        let companion_view = companion_wrap_data.as_ref().zip(companion_ref).map(
+            |((snapshot, edits), companion)| {
+                CompanionView::new(self.entity_id, snapshot, edits, companion)
+            },
+        );
 
         let mut block_map = self.block_map.write(
             self_wrap_snapshot.clone(),
             self_wrap_edits.clone(),
-            companion_wrap_edits,
-            companion_ref.map(|c| (c, self.entity_id)),
+            companion_view,
         );
         block_map.fold_buffers(buffer_ids.iter().copied(), self.buffer.read(cx), cx);
 
@@ -911,8 +936,14 @@ impl DisplayMap {
                     let mut block_map = dm.block_map.write(
                         companion_snapshot,
                         companion_edits,
-                        Some((&self_wrap_snapshot, &self_wrap_edits)),
-                        their_companion_ref.map(|c| (c, dm.entity_id)),
+                        their_companion_ref.map(|c| {
+                            CompanionView::new(
+                                dm.entity_id,
+                                &self_wrap_snapshot,
+                                &self_wrap_edits,
+                                c,
+                            )
+                        }),
                     );
                     if !their_buffer_ids.is_empty() {
                         block_map.fold_buffers(their_buffer_ids, dm.buffer.read(cx), cx);
@@ -954,16 +985,17 @@ impl DisplayMap {
                 .ok()
         });
 
-        let companion_wrap_edits = companion_wrap_data
-            .as_ref()
-            .map(|(snapshot, edits)| (snapshot, edits));
         let companion_ref = self.companion.as_ref().map(|(_, c)| c.read(cx));
+        let companion_view = companion_wrap_data.as_ref().zip(companion_ref).map(
+            |((snapshot, edits), companion)| {
+                CompanionView::new(self.entity_id, snapshot, edits, companion)
+            },
+        );
 
         let mut block_map = self.block_map.write(
             self_wrap_snapshot.clone(),
             self_wrap_edits.clone(),
-            companion_wrap_edits,
-            companion_ref.map(|c| (c, self.entity_id)),
+            companion_view,
         );
         block_map.unfold_buffers(buffer_ids.iter().copied(), self.buffer.read(cx), cx);
 
@@ -982,8 +1014,14 @@ impl DisplayMap {
                     let mut block_map = dm.block_map.write(
                         companion_snapshot,
                         companion_edits,
-                        Some((&self_wrap_snapshot, &self_wrap_edits)),
-                        their_companion_ref.map(|c| (c, dm.entity_id)),
+                        their_companion_ref.map(|c| {
+                            CompanionView::new(
+                                dm.entity_id,
+                                &self_wrap_snapshot,
+                                &self_wrap_edits,
+                                c,
+                            )
+                        }),
                     );
                     if !their_buffer_ids.is_empty() {
                         block_map.unfold_buffers(their_buffer_ids, dm.buffer.read(cx), cx);
@@ -1037,16 +1075,17 @@ impl DisplayMap {
                 .ok()
         });
 
-        let companion_wrap_edits = companion_wrap_data
-            .as_ref()
-            .map(|(snapshot, edits)| (snapshot, edits));
         let companion_ref = self.companion.as_ref().map(|(_, c)| c.read(cx));
+        let companion_view = companion_wrap_data.as_ref().zip(companion_ref).map(
+            |((snapshot, edits), companion)| {
+                CompanionView::new(self.entity_id, snapshot, edits, companion)
+            },
+        );
 
         let mut block_map = self.block_map.write(
             self_wrap_snapshot.clone(),
             self_wrap_edits.clone(),
-            companion_wrap_edits,
-            companion_ref.map(|c| (c, self.entity_id)),
+            companion_view,
         );
         let result = block_map.insert(blocks);
 
@@ -1057,8 +1096,14 @@ impl DisplayMap {
                     dm.block_map.read(
                         companion_snapshot,
                         companion_edits,
-                        Some((&self_wrap_snapshot, &self_wrap_edits)),
-                        their_companion_ref.map(|c| (c, dm.entity_id)),
+                        their_companion_ref.map(|c| {
+                            CompanionView::new(
+                                dm.entity_id,
+                                &self_wrap_snapshot,
+                                &self_wrap_edits,
+                                c,
+                            )
+                        }),
                     );
                 }
             });
@@ -1077,16 +1122,17 @@ impl DisplayMap {
                 .ok()
         });
 
-        let companion_wrap_edits = companion_wrap_data
-            .as_ref()
-            .map(|(snapshot, edits)| (snapshot, edits));
         let companion_ref = self.companion.as_ref().map(|(_, c)| c.read(cx));
+        let companion_view = companion_wrap_data.as_ref().zip(companion_ref).map(
+            |((snapshot, edits), companion)| {
+                CompanionView::new(self.entity_id, snapshot, edits, companion)
+            },
+        );
 
         let mut block_map = self.block_map.write(
             self_wrap_snapshot.clone(),
             self_wrap_edits.clone(),
-            companion_wrap_edits,
-            companion_ref.map(|c| (c, self.entity_id)),
+            companion_view,
         );
         block_map.resize(heights);
 
@@ -1097,8 +1143,14 @@ impl DisplayMap {
                     dm.block_map.read(
                         companion_snapshot,
                         companion_edits,
-                        Some((&self_wrap_snapshot, &self_wrap_edits)),
-                        their_companion_ref.map(|c| (c, dm.entity_id)),
+                        their_companion_ref.map(|c| {
+                            CompanionView::new(
+                                dm.entity_id,
+                                &self_wrap_snapshot,
+                                &self_wrap_edits,
+                                c,
+                            )
+                        }),
                     );
                 }
             });
@@ -1120,16 +1172,17 @@ impl DisplayMap {
                 .ok()
         });
 
-        let companion_wrap_edits = companion_wrap_data
-            .as_ref()
-            .map(|(snapshot, edits)| (snapshot, edits));
         let companion_ref = self.companion.as_ref().map(|(_, c)| c.read(cx));
+        let companion_view = companion_wrap_data.as_ref().zip(companion_ref).map(
+            |((snapshot, edits), companion)| {
+                CompanionView::new(self.entity_id, snapshot, edits, companion)
+            },
+        );
 
         let mut block_map = self.block_map.write(
             self_wrap_snapshot.clone(),
             self_wrap_edits.clone(),
-            companion_wrap_edits,
-            companion_ref.map(|c| (c, self.entity_id)),
+            companion_view,
         );
         block_map.remove(ids);
 
@@ -1140,8 +1193,14 @@ impl DisplayMap {
                     dm.block_map.read(
                         companion_snapshot,
                         companion_edits,
-                        Some((&self_wrap_snapshot, &self_wrap_edits)),
-                        their_companion_ref.map(|c| (c, dm.entity_id)),
+                        their_companion_ref.map(|c| {
+                            CompanionView::new(
+                                dm.entity_id,
+                                &self_wrap_snapshot,
+                                &self_wrap_edits,
+                                c,
+                            )
+                        }),
                     );
                 }
             });
@@ -1162,16 +1221,17 @@ impl DisplayMap {
                 .ok()
         });
 
-        let companion_wrap_edits = companion_wrap_data
-            .as_ref()
-            .map(|(snapshot, edits)| (snapshot, edits));
         let companion_ref = self.companion.as_ref().map(|(_, c)| c.read(cx));
+        let companion_view = companion_wrap_data.as_ref().zip(companion_ref).map(
+            |((snapshot, edits), companion)| {
+                CompanionView::new(self.entity_id, snapshot, edits, companion)
+            },
+        );
 
         let block_map = self.block_map.read(
             self_wrap_snapshot.clone(),
             self_wrap_edits.clone(),
-            companion_wrap_edits,
-            companion_ref.map(|c| (c, self.entity_id)),
+            companion_view,
         );
         let block_row = block_map.row_for_block(block_id)?;
 
@@ -1182,8 +1242,14 @@ impl DisplayMap {
                     dm.block_map.read(
                         companion_snapshot,
                         companion_edits,
-                        Some((&self_wrap_snapshot, &self_wrap_edits)),
-                        their_companion_ref.map(|c| (c, dm.entity_id)),
+                        their_companion_ref.map(|c| {
+                            CompanionView::new(
+                                dm.entity_id,
+                                &self_wrap_snapshot,
+                                &self_wrap_edits,
+                                c,
+                            )
+                        }),
                     );
                 }
             });
@@ -1298,10 +1364,6 @@ impl DisplayMap {
                 .ok()
         });
 
-        let companion_wrap_edits = companion_wrap_data
-            .as_ref()
-            .map(|(snapshot, edits)| (snapshot, edits));
-
         let (snapshot, edits) = self.inlay_map.sync(snapshot, edits);
         let (mut fold_map, snapshot, edits) = self.fold_map.write(snapshot, edits);
         let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
@@ -1309,13 +1371,15 @@ impl DisplayMap {
             .wrap_map
             .update(cx, |map, cx| map.sync(snapshot, edits, cx));
 
-        let companion_ref = self.companion.as_ref().map(|(_, c)| c.read(cx));
-        self.block_map.read(
-            snapshot,
-            edits,
-            companion_wrap_edits,
-            companion_ref.map(|c| (c, self.entity_id)),
-        );
+        {
+            let companion_ref = self.companion.as_ref().map(|(_, c)| c.read(cx));
+            let companion_view = companion_wrap_data.as_ref().zip(companion_ref).map(
+                |((snapshot, edits), companion)| {
+                    CompanionView::new(self.entity_id, snapshot, edits, companion)
+                },
+            );
+            self.block_map.read(snapshot, edits, companion_view);
+        }
 
         let (snapshot, edits) = fold_map.update_fold_widths(widths);
         let widths_changed = !edits.is_empty();
@@ -1327,17 +1391,16 @@ impl DisplayMap {
         let (self_wrap_snapshot, self_wrap_edits) =
             (self_new_wrap_snapshot.clone(), self_new_wrap_edits.clone());
 
-        let companion_wrap_edits = companion_wrap_data
-            .as_ref()
-            .map(|(snapshot, edits)| (snapshot, edits));
-        let companion_ref = self.companion.as_ref().map(|(_, c)| c.read(cx));
-
-        self.block_map.read(
-            self_new_wrap_snapshot,
-            self_new_wrap_edits,
-            companion_wrap_edits,
-            companion_ref.map(|c| (c, self.entity_id)),
-        );
+        {
+            let companion_ref = self.companion.as_ref().map(|(_, c)| c.read(cx));
+            let companion_view = companion_wrap_data.as_ref().zip(companion_ref).map(
+                |((snapshot, edits), companion)| {
+                    CompanionView::new(self.entity_id, snapshot, edits, companion)
+                },
+            );
+            self.block_map
+                .read(self_new_wrap_snapshot, self_new_wrap_edits, companion_view);
+        }
 
         if let Some((companion_dm, _)) = &self.companion {
             let _ = companion_dm.update(cx, |dm, cx| {
@@ -1346,8 +1409,14 @@ impl DisplayMap {
                     dm.block_map.read(
                         companion_snapshot,
                         companion_edits,
-                        Some((&self_wrap_snapshot, &self_wrap_edits)),
-                        their_companion_ref.map(|c| (c, dm.entity_id)),
+                        their_companion_ref.map(|c| {
+                            CompanionView::new(
+                                dm.entity_id,
+                                &self_wrap_snapshot,
+                                &self_wrap_edits,
+                                c,
+                            )
+                        }),
                     );
                 }
             });
@@ -1380,10 +1449,6 @@ impl DisplayMap {
                 .ok()
         });
 
-        let companion_wrap_edits = companion_wrap_data
-            .as_ref()
-            .map(|(snapshot, edits)| (snapshot, edits));
-
         let (snapshot, edits) = self.inlay_map.sync(buffer_snapshot, edits);
         let (snapshot, edits) = self.fold_map.read(snapshot, edits);
         let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
@@ -1391,13 +1456,15 @@ impl DisplayMap {
             .wrap_map
             .update(cx, |map, cx| map.sync(snapshot, edits, cx));
 
-        let companion_ref = self.companion.as_ref().map(|(_, c)| c.read(cx));
-        self.block_map.read(
-            snapshot,
-            edits,
-            companion_wrap_edits,
-            companion_ref.map(|c| (c, self.entity_id)),
-        );
+        {
+            let companion_ref = self.companion.as_ref().map(|(_, c)| c.read(cx));
+            let companion_view = companion_wrap_data.as_ref().zip(companion_ref).map(
+                |((snapshot, edits), companion)| {
+                    CompanionView::new(self.entity_id, snapshot, edits, companion)
+                },
+            );
+            self.block_map.read(snapshot, edits, companion_view);
+        }
 
         let (snapshot, edits) = self.inlay_map.splice(to_remove, to_insert);
         let (snapshot, edits) = self.fold_map.read(snapshot, edits);
@@ -1409,17 +1476,16 @@ impl DisplayMap {
         let (self_wrap_snapshot, self_wrap_edits) =
             (self_new_wrap_snapshot.clone(), self_new_wrap_edits.clone());
 
-        let companion_wrap_edits = companion_wrap_data
-            .as_ref()
-            .map(|(snapshot, edits)| (snapshot, edits));
-        let companion_ref = self.companion.as_ref().map(|(_, c)| c.read(cx));
-
-        self.block_map.read(
-            self_new_wrap_snapshot,
-            self_new_wrap_edits,
-            companion_wrap_edits,
-            companion_ref.map(|c| (c, self.entity_id)),
-        );
+        {
+            let companion_ref = self.companion.as_ref().map(|(_, c)| c.read(cx));
+            let companion_view = companion_wrap_data.as_ref().zip(companion_ref).map(
+                |((snapshot, edits), companion)| {
+                    CompanionView::new(self.entity_id, snapshot, edits, companion)
+                },
+            );
+            self.block_map
+                .read(self_new_wrap_snapshot, self_new_wrap_edits, companion_view);
+        }
 
         if let Some((companion_dm, _)) = &self.companion {
             let _ = companion_dm.update(cx, |dm, cx| {
@@ -1428,8 +1494,14 @@ impl DisplayMap {
                     dm.block_map.read(
                         companion_snapshot,
                         companion_edits,
-                        Some((&self_wrap_snapshot, &self_wrap_edits)),
-                        their_companion_ref.map(|c| (c, dm.entity_id)),
+                        their_companion_ref.map(|c| {
+                            CompanionView::new(
+                                dm.entity_id,
+                                &self_wrap_snapshot,
+                                &self_wrap_edits,
+                                c,
+                            )
+                        }),
                     );
                 }
             });

crates/editor/src/display_map/block_map.rs

@@ -57,10 +57,14 @@ pub struct BlockMapWriter<'a> {
     companion: Option<BlockMapWriterCompanion<'a>>,
 }
 
-struct BlockMapWriterCompanion<'a> {
-    companion: &'a Companion,
-    snapshot: &'a WrapSnapshot,
-    entity: EntityId,
+struct BlockMapWriterCompanion<'a>(CompanionView<'a>);
+
+impl<'a> Deref for BlockMapWriterCompanion<'a> {
+    type Target = CompanionView<'a>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
 }
 
 #[derive(Clone)]
@@ -514,6 +518,30 @@ pub struct BlockRows<'a> {
     started: bool,
 }
 
+#[derive(Clone, Copy)]
+pub struct CompanionView<'a> {
+    entity_id: EntityId,
+    wrap_snapshot: &'a WrapSnapshot,
+    wrap_edits: &'a WrapPatch,
+    companion: &'a Companion,
+}
+
+impl<'a> CompanionView<'a> {
+    pub(crate) fn new(
+        entity_id: EntityId,
+        wrap_snapshot: &'a WrapSnapshot,
+        wrap_edits: &'a WrapPatch,
+        companion: &'a Companion,
+    ) -> Self {
+        Self {
+            entity_id,
+            wrap_snapshot,
+            wrap_edits,
+            companion,
+        }
+    }
+}
+
 impl BlockMap {
     #[ztracing::instrument(skip_all)]
     pub fn new(
@@ -542,7 +570,6 @@ impl BlockMap {
                 new: WrapRow(0)..row_count,
             }]),
             None,
-            None,
         );
         map
     }
@@ -552,10 +579,9 @@ impl BlockMap {
         &self,
         wrap_snapshot: WrapSnapshot,
         edits: WrapPatch,
-        companion_wrap_edits: Option<(&WrapSnapshot, &WrapPatch)>,
-        companion: Option<(&Companion, EntityId)>,
+        companion_view: Option<CompanionView>,
     ) -> BlockMapReader<'_> {
-        self.sync(&wrap_snapshot, edits, companion_wrap_edits, companion);
+        self.sync(&wrap_snapshot, edits, companion_view);
         *self.wrap_snapshot.borrow_mut() = wrap_snapshot.clone();
         BlockMapReader {
             blocks: &self.custom_blocks,
@@ -574,23 +600,13 @@ impl BlockMap {
         &'a mut self,
         wrap_snapshot: WrapSnapshot,
         edits: WrapPatch,
-        companion_wrap_edits: Option<(&'a WrapSnapshot, &'a WrapPatch)>,
-        companion: Option<(&'a Companion, EntityId)>,
+        companion_view: Option<CompanionView<'a>>,
     ) -> BlockMapWriter<'a> {
-        self.sync(&wrap_snapshot, edits, companion_wrap_edits, companion);
+        self.sync(&wrap_snapshot, edits, companion_view);
         *self.wrap_snapshot.borrow_mut() = wrap_snapshot;
-        let companion = match (companion_wrap_edits, companion) {
-            (Some(_), None) | (None, Some(_)) => unreachable!(),
-            (None, None) => None,
-            (Some(companion_wrap_edits), Some(companion)) => Some(BlockMapWriterCompanion {
-                companion: companion.0,
-                snapshot: companion_wrap_edits.0,
-                entity: companion.1,
-            }),
-        };
         BlockMapWriter {
             block_map: self,
-            companion,
+            companion: companion_view.map(BlockMapWriterCompanion),
         }
     }
 
@@ -599,8 +615,7 @@ impl BlockMap {
         &self,
         wrap_snapshot: &WrapSnapshot,
         mut edits: WrapPatch,
-        companion_wrap_edits: Option<(&WrapSnapshot, &WrapPatch)>,
-        companion: Option<(&Companion, EntityId)>,
+        companion_view: Option<CompanionView>,
     ) {
         let buffer = wrap_snapshot.buffer_snapshot();
 
@@ -622,8 +637,13 @@ impl BlockMap {
         }
 
         // Pull in companion edits to ensure we recompute spacers in ranges that have changed in the companion.
-        if let Some((companion_new_snapshot, companion_edits)) = companion_wrap_edits
-            && let Some((companion, display_map_id)) = companion
+        if let Some(CompanionView {
+            wrap_snapshot: companion_new_snapshot,
+            wrap_edits: companion_edits,
+            companion,
+            entity_id: display_map_id,
+            ..
+        }) = companion_view
         {
             let mut companion_edits_in_my_space: Vec<WrapEdit> = companion_edits
                 .clone()
@@ -893,8 +913,12 @@ impl BlockMap {
                 },
             ));
 
-            if let Some((companion_snapshot, _)) = companion_wrap_edits
-                && let Some((companion, display_map_id)) = companion
+            if let Some(CompanionView {
+                wrap_snapshot: companion_snapshot,
+                companion,
+                entity_id: display_map_id,
+                ..
+            }) = companion_view
             {
                 blocks_in_edit.extend(self.spacer_blocks(
                     (start_bound, end_bound),
@@ -1495,18 +1519,20 @@ impl BlockMapWriter<'_> {
         }
 
         let default_patch = Patch::default();
-        let (companion_snapshot, companion) = self
-            .companion
-            .as_ref()
-            .map(|companion| {
-                (
-                    (companion.snapshot, &default_patch),
-                    (companion.companion, companion.entity),
-                )
-            })
-            .unzip();
-        self.block_map
-            .sync(wrap_snapshot, edits, companion_snapshot, companion);
+        self.block_map.sync(
+            wrap_snapshot,
+            edits,
+            self.companion.as_deref().map(
+                |&CompanionView {
+                     entity_id,
+                     wrap_snapshot,
+                     companion,
+                     ..
+                 }| {
+                    CompanionView::new(entity_id, wrap_snapshot, &default_patch, companion)
+                },
+            ),
+        );
         ids
     }
 
@@ -1563,18 +1589,20 @@ impl BlockMapWriter<'_> {
         }
 
         let default_patch = Patch::default();
-        let (companion_snapshot, companion) = self
-            .companion
-            .as_ref()
-            .map(|companion| {
-                (
-                    (companion.snapshot, &default_patch),
-                    (companion.companion, companion.entity),
-                )
-            })
-            .unzip();
-        self.block_map
-            .sync(wrap_snapshot, edits, companion_snapshot, companion);
+        self.block_map.sync(
+            wrap_snapshot,
+            edits,
+            self.companion.as_deref().map(
+                |&CompanionView {
+                     entity_id,
+                     wrap_snapshot,
+                     companion,
+                     ..
+                 }| {
+                    CompanionView::new(entity_id, wrap_snapshot, &default_patch, companion)
+                },
+            ),
+        );
     }
 
     #[ztracing::instrument(skip_all)]
@@ -1621,19 +1649,20 @@ impl BlockMapWriter<'_> {
             .custom_blocks_by_id
             .retain(|id, _| !block_ids.contains(id));
         let default_patch = Patch::default();
-        let (companion_snapshot, companion) = self
-            .companion
-            .as_ref()
-            .map(|companion| {
-                (
-                    (companion.snapshot, &default_patch),
-                    (companion.companion, companion.entity),
-                )
-            })
-            .unzip();
-
-        self.block_map
-            .sync(wrap_snapshot, edits, companion_snapshot, companion);
+        self.block_map.sync(
+            wrap_snapshot,
+            edits,
+            self.companion.as_deref().map(
+                |&CompanionView {
+                     entity_id,
+                     wrap_snapshot,
+                     companion,
+                     ..
+                 }| {
+                    CompanionView::new(entity_id, wrap_snapshot, &default_patch, companion)
+                },
+            ),
+        );
     }
 
     #[ztracing::instrument(skip_all)]
@@ -1715,18 +1744,20 @@ impl BlockMapWriter<'_> {
         }
 
         let default_patch = Patch::default();
-        let (companion_snapshot, companion) = self
-            .companion
-            .as_ref()
-            .map(|companion| {
-                (
-                    (companion.snapshot, &default_patch),
-                    (companion.companion, companion.entity),
-                )
-            })
-            .unzip();
-        self.block_map
-            .sync(&wrap_snapshot, edits, companion_snapshot, companion);
+        self.block_map.sync(
+            &wrap_snapshot,
+            edits,
+            self.companion.as_deref().map(
+                |&CompanionView {
+                     entity_id,
+                     wrap_snapshot,
+                     companion,
+                     ..
+                 }| {
+                    CompanionView::new(entity_id, wrap_snapshot, &default_patch, companion)
+                },
+            ),
+        );
     }
 
     #[ztracing::instrument(skip_all)]
@@ -2531,7 +2562,7 @@ mod tests {
             cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
         let mut block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1);
 
-        let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None, None);
+        let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
         let block_ids = writer.insert(vec![
             BlockProperties {
                 style: BlockStyle::Fixed,
@@ -2556,7 +2587,7 @@ mod tests {
             },
         ]);
 
-        let snapshot = block_map.read(wraps_snapshot, Default::default(), None, None);
+        let snapshot = block_map.read(wraps_snapshot, Default::default(), None);
         assert_eq!(snapshot.text(), "aaa\n\n\n\nbbb\nccc\nddd\n\n\n");
 
         let blocks = snapshot
@@ -2681,7 +2712,7 @@ mod tests {
         let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
             wrap_map.sync(tab_snapshot, tab_edits, cx)
         });
-        let snapshot = block_map.read(wraps_snapshot, wrap_edits, None, None);
+        let snapshot = block_map.read(wraps_snapshot, wrap_edits, None);
         assert_eq!(snapshot.text(), "aaa\n\nb!!!\n\n\nbb\nccc\nddd\n\n\n");
     }
 
@@ -2734,7 +2765,7 @@ mod tests {
         let (_, wraps_snapshot) = WrapMap::new(tab_snapshot, font, font_size, Some(wrap_width), cx);
 
         let block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1);
-        let snapshot = block_map.read(wraps_snapshot, Default::default(), None, None);
+        let snapshot = block_map.read(wraps_snapshot, Default::default(), None);
 
         // Each excerpt has a header above and footer below. Excerpts are also *separated* by a newline.
         assert_eq!(snapshot.text(), "\nBuff\ner 1\n\nBuff\ner 2\n\nBuff\ner 3");
@@ -2769,7 +2800,7 @@ mod tests {
             cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
         let mut block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1);
 
-        let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None, None);
+        let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
         let block_ids = writer.insert(vec![
             BlockProperties {
                 style: BlockStyle::Fixed,
@@ -2795,64 +2826,64 @@ mod tests {
         ]);
 
         {
-            let snapshot = block_map.read(wraps_snapshot.clone(), Default::default(), None, None);
+            let snapshot = block_map.read(wraps_snapshot.clone(), Default::default(), None);
             assert_eq!(snapshot.text(), "aaa\n\n\n\nbbb\nccc\nddd\n\n\n");
 
             let mut block_map_writer =
-                block_map.write(wraps_snapshot.clone(), Default::default(), None, None);
+                block_map.write(wraps_snapshot.clone(), Default::default(), None);
 
             let mut new_heights = HashMap::default();
             new_heights.insert(block_ids[0], 2);
             block_map_writer.resize(new_heights);
-            let snapshot = block_map.read(wraps_snapshot.clone(), Default::default(), None, None);
+            let snapshot = block_map.read(wraps_snapshot.clone(), Default::default(), None);
             assert_eq!(snapshot.text(), "aaa\n\n\n\n\nbbb\nccc\nddd\n\n\n");
         }
 
         {
             let mut block_map_writer =
-                block_map.write(wraps_snapshot.clone(), Default::default(), None, None);
+                block_map.write(wraps_snapshot.clone(), Default::default(), None);
 
             let mut new_heights = HashMap::default();
             new_heights.insert(block_ids[0], 1);
             block_map_writer.resize(new_heights);
 
-            let snapshot = block_map.read(wraps_snapshot.clone(), Default::default(), None, None);
+            let snapshot = block_map.read(wraps_snapshot.clone(), Default::default(), None);
             assert_eq!(snapshot.text(), "aaa\n\n\n\nbbb\nccc\nddd\n\n\n");
         }
 
         {
             let mut block_map_writer =
-                block_map.write(wraps_snapshot.clone(), Default::default(), None, None);
+                block_map.write(wraps_snapshot.clone(), Default::default(), None);
 
             let mut new_heights = HashMap::default();
             new_heights.insert(block_ids[0], 0);
             block_map_writer.resize(new_heights);
 
-            let snapshot = block_map.read(wraps_snapshot.clone(), Default::default(), None, None);
+            let snapshot = block_map.read(wraps_snapshot.clone(), Default::default(), None);
             assert_eq!(snapshot.text(), "aaa\n\n\nbbb\nccc\nddd\n\n\n");
         }
 
         {
             let mut block_map_writer =
-                block_map.write(wraps_snapshot.clone(), Default::default(), None, None);
+                block_map.write(wraps_snapshot.clone(), Default::default(), None);
 
             let mut new_heights = HashMap::default();
             new_heights.insert(block_ids[0], 3);
             block_map_writer.resize(new_heights);
 
-            let snapshot = block_map.read(wraps_snapshot.clone(), Default::default(), None, None);
+            let snapshot = block_map.read(wraps_snapshot.clone(), Default::default(), None);
             assert_eq!(snapshot.text(), "aaa\n\n\n\n\n\nbbb\nccc\nddd\n\n\n");
         }
 
         {
             let mut block_map_writer =
-                block_map.write(wraps_snapshot.clone(), Default::default(), None, None);
+                block_map.write(wraps_snapshot.clone(), Default::default(), None);
 
             let mut new_heights = HashMap::default();
             new_heights.insert(block_ids[0], 3);
             block_map_writer.resize(new_heights);
 
-            let snapshot = block_map.read(wraps_snapshot, Default::default(), None, None);
+            let snapshot = block_map.read(wraps_snapshot, Default::default(), None);
             // Same height as before, should remain the same
             assert_eq!(snapshot.text(), "aaa\n\n\n\n\n\nbbb\nccc\nddd\n\n\n");
         }
@@ -2874,7 +2905,7 @@ mod tests {
         });
         let mut block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1);
 
-        let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None, None);
+        let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
         writer.insert(vec![
             BlockProperties {
                 style: BlockStyle::Fixed,
@@ -2894,7 +2925,7 @@ mod tests {
 
         // Blocks with an 'above' disposition go above their corresponding buffer line.
         // Blocks with a 'below' disposition go below their corresponding buffer line.
-        let snapshot = block_map.read(wraps_snapshot, Default::default(), None, None);
+        let snapshot = block_map.read(wraps_snapshot, Default::default(), None);
         assert_eq!(
             snapshot.text(),
             "one two \nthree\n\nfour five \nsix\n\nseven \neight"
@@ -2918,7 +2949,7 @@ mod tests {
             cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
         let mut block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1);
 
-        let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None, None);
+        let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
         let replace_block_id = writer.insert(vec![BlockProperties {
             style: BlockStyle::Fixed,
             placement: BlockPlacement::Replace(
@@ -2930,7 +2961,7 @@ mod tests {
             priority: 0,
         }])[0];
 
-        let blocks_snapshot = block_map.read(wraps_snapshot, Default::default(), None, None);
+        let blocks_snapshot = block_map.read(wraps_snapshot, Default::default(), None);
         assert_eq!(blocks_snapshot.text(), "line1\n\n\n\n\nline5");
 
         let buffer_snapshot = buffer.update(cx, |buffer, cx| {
@@ -2944,7 +2975,7 @@ mod tests {
         let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
             wrap_map.sync(tab_snapshot, tab_edits, cx)
         });
-        let blocks_snapshot = block_map.read(wraps_snapshot, wrap_edits, None, None);
+        let blocks_snapshot = block_map.read(wraps_snapshot, wrap_edits, None);
         assert_eq!(blocks_snapshot.text(), "line1\n\n\n\n\nline5");
 
         let buffer_snapshot = buffer.update(cx, |buffer, cx| {
@@ -2967,11 +2998,11 @@ mod tests {
         let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
             wrap_map.sync(tab_snapshot, tab_edits, cx)
         });
-        let blocks_snapshot = block_map.read(wraps_snapshot.clone(), wrap_edits, None, None);
+        let blocks_snapshot = block_map.read(wraps_snapshot.clone(), wrap_edits, None);
         assert_eq!(blocks_snapshot.text(), "line1\n\n\n\n\nline5");
 
         // Blocks inserted right above the start or right below the end of the replaced region are hidden.
-        let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None, None);
+        let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
         writer.insert(vec![
             BlockProperties {
                 style: BlockStyle::Fixed,
@@ -2995,12 +3026,11 @@ mod tests {
                 priority: 0,
             },
         ]);
-        let blocks_snapshot =
-            block_map.read(wraps_snapshot.clone(), Default::default(), None, None);
+        let blocks_snapshot = block_map.read(wraps_snapshot.clone(), Default::default(), None);
         assert_eq!(blocks_snapshot.text(), "\nline1\n\n\n\n\nline5");
 
         // Ensure blocks inserted *inside* replaced region are hidden.
-        let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None, None);
+        let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
         writer.insert(vec![
             BlockProperties {
                 style: BlockStyle::Fixed,
@@ -3024,14 +3054,13 @@ mod tests {
                 priority: 0,
             },
         ]);
-        let blocks_snapshot =
-            block_map.read(wraps_snapshot.clone(), Default::default(), None, None);
+        let blocks_snapshot = block_map.read(wraps_snapshot.clone(), Default::default(), None);
         assert_eq!(blocks_snapshot.text(), "\nline1\n\n\n\n\nline5");
 
         // Removing the replace block shows all the hidden blocks again.
-        let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None, None);
+        let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
         writer.remove(HashSet::from_iter([replace_block_id]));
-        let blocks_snapshot = block_map.read(wraps_snapshot, Default::default(), None, None);
+        let blocks_snapshot = block_map.read(wraps_snapshot, Default::default(), None);
         assert_eq!(
             blocks_snapshot.text(),
             "\nline1\n\nline2\n\n\nline 2.1\nline2.2\nline 2.3\nline 2.4\n\nline4\n\nline5"
@@ -3084,7 +3113,7 @@ mod tests {
         let (_, wrap_snapshot) =
             cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
         let mut block_map = BlockMap::new(wrap_snapshot.clone(), 2, 1);
-        let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None, None);
+        let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None);
 
         assert_eq!(
             blocks_snapshot.text(),
@@ -3114,7 +3143,7 @@ mod tests {
             ]
         );
 
-        let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None, None);
+        let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None);
         let excerpt_blocks_2 = writer.insert(vec![
             BlockProperties {
                 style: BlockStyle::Fixed,
@@ -3155,7 +3184,7 @@ mod tests {
             },
         ]);
 
-        let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None, None);
+        let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None);
         assert_eq!(
             blocks_snapshot.text(),
             "\n\n111\n\n\n\n222\n\n\n333\n\n444\n\n\n\n\n555\n\n666\n"
@@ -3189,7 +3218,7 @@ mod tests {
             ]
         );
 
-        let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None, None);
+        let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None);
         buffer.read_with(cx, |buffer, cx| {
             writer.fold_buffers([buffer_id_1], buffer, cx);
         });
@@ -3200,7 +3229,7 @@ mod tests {
             render: Arc::new(|_| div().into_any()),
             priority: 0,
         }]);
-        let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None, None);
+        let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None);
         let blocks = blocks_snapshot
             .blocks_in_range(BlockRow(0)..BlockRow(u32::MAX))
             .collect::<Vec<_>>();
@@ -3257,11 +3286,11 @@ mod tests {
             ]
         );
 
-        let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None, None);
+        let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None);
         buffer.read_with(cx, |buffer, cx| {
             writer.fold_buffers([buffer_id_2], buffer, cx);
         });
-        let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None, None);
+        let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None);
         let blocks = blocks_snapshot
             .blocks_in_range(BlockRow(0)..BlockRow(u32::MAX))
             .collect::<Vec<_>>();
@@ -3310,11 +3339,11 @@ mod tests {
             ]
         );
 
-        let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None, None);
+        let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None);
         buffer.read_with(cx, |buffer, cx| {
             writer.unfold_buffers([buffer_id_1], buffer, cx);
         });
-        let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None, None);
+        let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None);
         let blocks = blocks_snapshot
             .blocks_in_range(BlockRow(0)..BlockRow(u32::MAX))
             .collect::<Vec<_>>();
@@ -3366,11 +3395,11 @@ mod tests {
             ]
         );
 
-        let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None, None);
+        let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None);
         buffer.read_with(cx, |buffer, cx| {
             writer.fold_buffers([buffer_id_3], buffer, cx);
         });
-        let blocks_snapshot = block_map.read(wrap_snapshot, Patch::default(), None, None);
+        let blocks_snapshot = block_map.read(wrap_snapshot, Patch::default(), None);
         let blocks = blocks_snapshot
             .blocks_in_range(BlockRow(0)..BlockRow(u32::MAX))
             .collect::<Vec<_>>();
@@ -3429,15 +3458,15 @@ mod tests {
         let (_, wrap_snapshot) =
             cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
         let mut block_map = BlockMap::new(wrap_snapshot.clone(), 2, 1);
-        let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None, None);
+        let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None);
 
         assert_eq!(blocks_snapshot.text(), "\n\n111");
 
-        let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None, None);
+        let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None);
         buffer.read_with(cx, |buffer, cx| {
             writer.fold_buffers([buffer_id], buffer, cx);
         });
-        let blocks_snapshot = block_map.read(wrap_snapshot, Patch::default(), None, None);
+        let blocks_snapshot = block_map.read(wrap_snapshot, Patch::default(), None);
         let blocks = blocks_snapshot
             .blocks_in_range(BlockRow(0)..BlockRow(u32::MAX))
             .collect::<Vec<_>>();
@@ -3565,7 +3594,7 @@ mod tests {
                     let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
                         wrap_map.sync(tab_snapshot, tab_edits, cx)
                     });
-                    let mut block_map = block_map.write(wraps_snapshot, wrap_edits, None, None);
+                    let mut block_map = block_map.write(wraps_snapshot, wrap_edits, None);
                     let block_ids =
                         block_map.insert(block_properties.iter().map(|props| BlockProperties {
                             placement: props.placement.clone(),
@@ -3603,7 +3632,7 @@ mod tests {
                     let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
                         wrap_map.sync(tab_snapshot, tab_edits, cx)
                     });
-                    let mut block_map = block_map.write(wraps_snapshot, wrap_edits, None, None);
+                    let mut block_map = block_map.write(wraps_snapshot, wrap_edits, None);
                     log::info!(
                         "removing {} blocks: {:?}",
                         block_ids_to_remove.len(),
@@ -3624,7 +3653,7 @@ mod tests {
                     let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
                         wrap_map.sync(tab_snapshot, tab_edits, cx)
                     });
-                    let mut block_map = block_map.write(wraps_snapshot, wrap_edits, None, None);
+                    let mut block_map = block_map.write(wraps_snapshot, wrap_edits, None);
                     let (unfolded_buffers, folded_buffers) = buffer.read_with(cx, |buffer, _| {
                         let folded_buffers: Vec<_> =
                             block_map.block_map.folded_buffers.iter().cloned().collect();
@@ -3708,7 +3737,7 @@ mod tests {
             let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
                 wrap_map.sync(tab_snapshot, tab_edits, cx)
             });
-            let blocks_snapshot = block_map.read(wraps_snapshot.clone(), wrap_edits, None, None);
+            let blocks_snapshot = block_map.read(wraps_snapshot.clone(), wrap_edits, None);
             assert_eq!(
                 blocks_snapshot.transforms.summary().input_rows,
                 wraps_snapshot.max_point().row() + RowDelta(1)
@@ -4097,7 +4126,7 @@ mod tests {
             cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
         let mut block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1);
 
-        let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None, None);
+        let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
         let _block_id = writer.insert(vec![BlockProperties {
             style: BlockStyle::Fixed,
             placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(1, 0))),
@@ -4106,11 +4135,10 @@ mod tests {
             priority: 0,
         }])[0];
 
-        let blocks_snapshot =
-            block_map.read(wraps_snapshot.clone(), Default::default(), None, None);
+        let blocks_snapshot = block_map.read(wraps_snapshot.clone(), Default::default(), None);
         assert_eq!(blocks_snapshot.text(), "abc\n\ndef\nghi\njkl\nmno");
 
-        let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None, None);
+        let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
         writer.remove_intersecting_replace_blocks(
             [buffer_snapshot
                 .anchor_after(Point::new(1, 0))
@@ -4120,7 +4148,7 @@ mod tests {
                     .to_offset(&buffer_snapshot)],
             false,
         );
-        let blocks_snapshot = block_map.read(wraps_snapshot, Default::default(), None, None);
+        let blocks_snapshot = block_map.read(wraps_snapshot, Default::default(), None);
         assert_eq!(blocks_snapshot.text(), "abc\n\ndef\nghi\njkl\nmno");
     }
 
@@ -4148,7 +4176,7 @@ mod tests {
             cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
         let mut block_map = BlockMap::new(wrap_snapshot.clone(), 1, 1);
 
-        let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None, None);
+        let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None);
         writer.insert(vec![BlockProperties {
             style: BlockStyle::Fixed,
             placement: BlockPlacement::Near(buffer_snapshot.anchor_after(Point::new(0, 0))),
@@ -4157,15 +4185,15 @@ mod tests {
             priority: 0,
         }]);
 
-        let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None, None);
+        let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None);
         assert_eq!(blocks_snapshot.text(), "\nline 1\n\nline 2\nline 3");
 
-        let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None, None);
+        let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None);
         buffer.read_with(cx, |buffer, cx| {
             writer.fold_buffers([buffer_id], buffer, cx);
         });
 
-        let blocks_snapshot = block_map.read(wrap_snapshot, Patch::default(), None, None);
+        let blocks_snapshot = block_map.read(wrap_snapshot, Patch::default(), None);
         assert_eq!(blocks_snapshot.text(), "");
     }
 
@@ -4193,7 +4221,7 @@ mod tests {
             cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
         let mut block_map = BlockMap::new(wrap_snapshot.clone(), 1, 1);
 
-        let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None, None);
+        let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None);
         writer.insert(vec![BlockProperties {
             style: BlockStyle::Fixed,
             placement: BlockPlacement::Near(buffer_snapshot.anchor_after(Point::new(3, 6))),
@@ -4202,15 +4230,15 @@ mod tests {
             priority: 0,
         }]);
 
-        let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None, None);
+        let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None);
         assert_eq!(blocks_snapshot.text(), "\nline 1\nline 2\nline 3\nline 4\n");
 
-        let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None, None);
+        let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None);
         buffer.read_with(cx, |buffer, cx| {
             writer.fold_buffers([buffer_id], buffer, cx);
         });
 
-        let blocks_snapshot = block_map.read(wrap_snapshot, Patch::default(), None, None);
+        let blocks_snapshot = block_map.read(wrap_snapshot, Patch::default(), None);
         assert_eq!(blocks_snapshot.text(), "");
     }
 
@@ -4299,8 +4327,12 @@ mod tests {
             rhs_block_map.read(
                 rhs_wrap_snapshot.clone(),
                 rhs_edits.clone(),
-                Some((&lhs_wrap_snapshot, &lhs_edits)),
-                Some((companion, rhs_entity_id)),
+                Some(CompanionView::new(
+                    rhs_entity_id,
+                    &lhs_wrap_snapshot,
+                    &lhs_edits,
+                    companion,
+                )),
             )
         });
 
@@ -4309,8 +4341,12 @@ mod tests {
             lhs_block_map.read(
                 lhs_wrap_snapshot.clone(),
                 lhs_edits.clone(),
-                Some((&rhs_wrap_snapshot, &rhs_edits)),
-                Some((companion, lhs_entity_id)),
+                Some(CompanionView::new(
+                    lhs_entity_id,
+                    &rhs_wrap_snapshot,
+                    &rhs_edits,
+                    companion,
+                )),
             )
         });
 
@@ -4400,8 +4436,12 @@ mod tests {
             rhs_block_map.read(
                 rhs_wrap_snapshot.clone(),
                 rhs_wrap_edits.clone(),
-                Some((&lhs_wrap_snapshot, &Default::default())),
-                Some((companion, rhs_entity_id)),
+                Some(CompanionView::new(
+                    rhs_entity_id,
+                    &lhs_wrap_snapshot,
+                    &Default::default(),
+                    companion,
+                )),
             )
         });
 
@@ -4409,8 +4449,12 @@ mod tests {
             lhs_block_map.read(
                 lhs_wrap_snapshot.clone(),
                 Default::default(),
-                Some((&rhs_wrap_snapshot, &rhs_wrap_edits)),
-                Some((companion, lhs_entity_id)),
+                Some(CompanionView::new(
+                    lhs_entity_id,
+                    &rhs_wrap_snapshot,
+                    &rhs_wrap_edits,
+                    companion,
+                )),
             )
         });