Extract a language crate

crates/editor/src/display_map.rs

@@ -2,9 +2,9 @@ mod fold_map;
 mod tab_map;
 mod wrap_map;
 
-use buffer::{Anchor, Buffer, Point, ToOffset, ToPoint};
 use fold_map::{FoldMap, ToFoldPoint as _};
 use gpui::{fonts::FontId, Entity, ModelContext, ModelHandle};
+use language::{Anchor, Buffer, Point, ToOffset, ToPoint};
 use std::ops::Range;
 use sum_tree::Bias;
 use tab_map::TabMap;
@@ -109,7 +109,7 @@ impl DisplayMap {
 }
 
 pub struct DisplayMapSnapshot {
-    buffer_snapshot: buffer::Snapshot,
+    buffer_snapshot: language::Snapshot,
     folds_snapshot: fold_map::Snapshot,
     tabs_snapshot: tab_map::Snapshot,
     wraps_snapshot: wrap_map::Snapshot,
@@ -358,8 +358,8 @@ impl ToDisplayPoint for Anchor {
 mod tests {
     use super::*;
     use crate::{movement, test::*};
-    use buffer::{History, Language, LanguageConfig, RandomCharIter, SelectionGoal};
     use gpui::{color::Color, MutableAppContext};
+    use language::{History, Language, LanguageConfig, RandomCharIter, SelectionGoal};
     use rand::{prelude::StdRng, Rng};
     use std::{env, sync::Arc};
     use theme::SyntaxTheme;
@@ -436,7 +436,7 @@ mod tests {
                     }
                 }
                 _ => {
-                    buffer.update(&mut cx, |buffer, cx| buffer.randomly_edit(&mut rng, 5));
+                    buffer.update(&mut cx, |buffer, _| buffer.randomly_edit(&mut rng, 5));
                 }
             }
 

crates/editor/src/display_map/fold_map.rs

@@ -1,5 +1,5 @@
-use buffer::{Anchor, AnchorRangeExt, Buffer, HighlightId, Point, TextSummary, ToOffset};
 use gpui::{AppContext, ModelHandle};
+use language::{Anchor, AnchorRangeExt, Buffer, HighlightId, Point, TextSummary, ToOffset};
 use parking_lot::Mutex;
 use std::{
     cmp::{self, Ordering},
@@ -485,7 +485,7 @@ impl FoldMap {
 pub struct Snapshot {
     transforms: SumTree<Transform>,
     folds: SumTree<Fold>,
-    buffer_snapshot: buffer::Snapshot,
+    buffer_snapshot: language::Snapshot,
     pub version: usize,
 }
 
@@ -994,7 +994,7 @@ impl<'a> Iterator for Chunks<'a> {
 
 pub struct HighlightedChunks<'a> {
     transform_cursor: Cursor<'a, Transform, (FoldOffset, usize)>,
-    buffer_chunks: buffer::HighlightedChunks<'a>,
+    buffer_chunks: language::HighlightedChunks<'a>,
     buffer_chunk: Option<(usize, &'a str, HighlightId)>,
     buffer_offset: usize,
 }
@@ -1331,7 +1331,7 @@ mod tests {
                     snapshot_edits.extend(map.randomly_mutate(&mut rng, cx.as_ref()));
                 }
                 _ => {
-                    let edits = buffer.update(cx, |buffer, cx| {
+                    let edits = buffer.update(cx, |buffer, _| {
                         let start_version = buffer.version.clone();
                         let edit_count = rng.gen_range(1..=5);
                         buffer.randomly_edit(&mut rng, edit_count);

crates/editor/src/display_map/tab_map.rs

@@ -1,5 +1,5 @@
 use super::fold_map::{self, FoldEdit, FoldPoint, Snapshot as FoldSnapshot};
-use buffer::{rope, HighlightId};
+use language::{rope, HighlightId};
 use parking_lot::Mutex;
 use std::{mem, ops::Range};
 use sum_tree::Bias;

crates/editor/src/display_map/wrap_map.rs

@@ -2,8 +2,8 @@ use super::{
     fold_map,
     tab_map::{self, Edit as TabEdit, Snapshot as TabSnapshot, TabPoint, TextSummary},
 };
-use buffer::{HighlightId, Point};
 use gpui::{fonts::FontId, text_layout::LineWrapper, Entity, ModelContext, Task};
+use language::{HighlightId, Point};
 use lazy_static::lazy_static;
 use smol::future::yield_now;
 use std::{collections::VecDeque, ops::Range, time::Duration};
@@ -899,7 +899,7 @@ mod tests {
         display_map::{fold_map::FoldMap, tab_map::TabMap},
         test::Observer,
     };
-    use buffer::{Buffer, RandomCharIter};
+    use language::{Buffer, RandomCharIter};
     use rand::prelude::*;
     use std::env;
 
@@ -990,7 +990,7 @@ mod tests {
                     }
                 }
                 _ => {
-                    buffer.update(&mut cx, |buffer, cx| buffer.randomly_mutate(&mut rng));
+                    buffer.update(&mut cx, |buffer, _| buffer.randomly_mutate(&mut rng));
                 }
             }
 

crates/editor/src/element.rs

@@ -2,7 +2,6 @@ use super::{
     DisplayPoint, Editor, EditorMode, EditorSettings, EditorStyle, Input, Scroll, Select,
     SelectPhase, Snapshot, MAX_LINE_LEN,
 };
-use buffer::HighlightId;
 use clock::ReplicaId;
 use gpui::{
     color::Color,
@@ -18,6 +17,7 @@ use gpui::{
     MutableAppContext, PaintContext, Quad, Scene, SizeConstraint, ViewContext, WeakViewHandle,
 };
 use json::json;
+use language::HighlightId;
 use smallvec::SmallVec;
 use std::{
     cmp::{self, Ordering},
@@ -1043,7 +1043,7 @@ mod tests {
         test::sample_text,
         {Editor, EditorSettings},
     };
-    use buffer::Buffer;
+    use language::Buffer;
 
     #[gpui::test]
     fn test_layout_line_numbers(cx: &mut gpui::MutableAppContext) {

crates/editor/src/lib.rs

@@ -5,7 +5,6 @@ pub mod movement;
 #[cfg(test)]
 mod test;
 
-use buffer::*;
 use clock::ReplicaId;
 pub use display_map::DisplayPoint;
 use display_map::*;
@@ -15,6 +14,7 @@ use gpui::{
     text_layout, AppContext, ClipboardItem, Element, ElementBox, Entity, ModelHandle,
     MutableAppContext, RenderContext, View, ViewContext, WeakViewHandle,
 };
+use language::*;
 use serde::{Deserialize, Serialize};
 use smallvec::SmallVec;
 use smol::Timer;
@@ -2661,17 +2661,17 @@ impl Editor {
     fn on_buffer_event(
         &mut self,
         _: ModelHandle<Buffer>,
-        event: &buffer::Event,
+        event: &language::Event,
         cx: &mut ViewContext<Self>,
     ) {
         match event {
-            buffer::Event::Edited => cx.emit(Event::Edited),
-            buffer::Event::Dirtied => cx.emit(Event::Dirtied),
-            buffer::Event::Saved => cx.emit(Event::Saved),
-            buffer::Event::FileHandleChanged => cx.emit(Event::FileHandleChanged),
-            buffer::Event::Reloaded => cx.emit(Event::FileHandleChanged),
-            buffer::Event::Closed => cx.emit(Event::Closed),
-            buffer::Event::Reparsed => {}
+            language::Event::Edited => cx.emit(Event::Edited),
+            language::Event::Dirtied => cx.emit(Event::Dirtied),
+            language::Event::Saved => cx.emit(Event::Saved),
+            language::Event::FileHandleChanged => cx.emit(Event::FileHandleChanged),
+            language::Event::Reloaded => cx.emit(Event::FileHandleChanged),
+            language::Event::Closed => cx.emit(Event::Closed),
+            language::Event::Reparsed => {}
         }
     }