From 1851e2e77cd0a1e59ec9c1487000d01311714f05 Mon Sep 17 00:00:00 2001 From: Max Brunsfeld Date: Thu, 19 Jan 2023 12:31:34 -0800 Subject: [PATCH] Start work on language config overrides Co-authored-by: Julia Risley --- crates/editor/src/editor.rs | 9 +- crates/editor/src/multi_buffer.rs | 11 +- crates/language/src/buffer.rs | 23 +++- crates/language/src/language.rs | 123 +++++++++++++++--- crates/language/src/syntax_map.rs | 35 +++++ .../zed/src/languages/javascript/contexts.scm | 0 crates/zed/src/languages/tsx/config.toml | 9 ++ crates/zed/src/languages/tsx/overrides.scm | 2 + 8 files changed, 189 insertions(+), 23 deletions(-) create mode 100644 crates/zed/src/languages/javascript/contexts.scm create mode 100644 crates/zed/src/languages/tsx/overrides.scm diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs index a6ce5626318b519593fa3de624610d7a817d8625..81ab73e24ea34008b9163f7da0147055771a5dc8 100644 --- a/crates/editor/src/editor.rs +++ b/crates/editor/src/editor.rs @@ -1737,7 +1737,7 @@ impl Editor { for (selection, autoclose_region) in self.selections_with_autoclose_regions(selections, &snapshot) { - if let Some(language) = snapshot.language_at(selection.head()) { + if let Some(language) = snapshot.language_config_at(selection.head()) { // Determine if the inserted text matches the opening or closing // bracket of any of this language's bracket pairs. let mut bracket_pair = None; @@ -1898,7 +1898,7 @@ impl Editor { let end = selection.end; let mut insert_extra_newline = false; - if let Some(language) = buffer.language_at(start) { + if let Some(language) = buffer.language_config_at(start) { let leading_whitespace_len = buffer .reversed_chars_at(start) .take_while(|c| c.is_whitespace() && *c != '\n') @@ -4533,7 +4533,10 @@ impl Editor { // TODO: Handle selections that cross excerpts for selection in &mut selections { - let language = if let Some(language) = snapshot.language_at(selection.start) { + let start_column = snapshot.indent_size_for_line(selection.start.row).len; + let language = if let Some(language) = + snapshot.language_config_at(Point::new(selection.start.row, start_column)) + { language } else { continue; diff --git a/crates/editor/src/multi_buffer.rs b/crates/editor/src/multi_buffer.rs index 6b5262c16ab97eff73491322a3f3607bcbb0b1d8..57fe5411cd732e39660b84ee65a6f0da79bb2532 100644 --- a/crates/editor/src/multi_buffer.rs +++ b/crates/editor/src/multi_buffer.rs @@ -10,9 +10,9 @@ use gpui::{AppContext, Entity, ModelContext, ModelHandle, Task}; pub use language::Completion; use language::{ char_kind, AutoindentMode, Buffer, BufferChunks, BufferSnapshot, CharKind, Chunk, CursorShape, - DiagnosticEntry, IndentSize, Language, OffsetRangeExt, OffsetUtf16, Outline, OutlineItem, - Point, PointUtf16, Selection, TextDimension, ToOffset as _, ToOffsetUtf16 as _, ToPoint as _, - ToPointUtf16 as _, TransactionId, Unclipped, + DiagnosticEntry, IndentSize, Language, LanguageConfigYeet, OffsetRangeExt, OffsetUtf16, + Outline, OutlineItem, Point, PointUtf16, Selection, TextDimension, ToOffset as _, + ToOffsetUtf16 as _, ToPoint as _, ToPointUtf16 as _, TransactionId, Unclipped, }; use std::{ borrow::Cow, @@ -2691,6 +2691,11 @@ impl MultiBufferSnapshot { .and_then(|(buffer, offset)| buffer.language_at(offset)) } + pub fn language_config_at<'a, T: ToOffset>(&'a self, point: T) -> Option { + self.point_to_buffer_offset(point) + .and_then(|(buffer, offset)| buffer.language_config_at(offset)) + } + pub fn is_dirty(&self) -> bool { self.is_dirty } diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs index ad3bdb6821d2c80b781a52b44c3ab7a8c567041e..5593241e70ba305d59855dc475631b36f872a020 100644 --- a/crates/language/src/buffer.rs +++ b/crates/language/src/buffer.rs @@ -9,7 +9,7 @@ use crate::{ syntax_map::{ SyntaxMap, SyntaxMapCapture, SyntaxMapCaptures, SyntaxSnapshot, ToTreeSitterPoint, }, - CodeLabel, Outline, + CodeLabel, LanguageConfigYeet, Outline, }; use anyhow::{anyhow, Result}; use clock::ReplicaId; @@ -2015,6 +2015,27 @@ impl BufferSnapshot { .or(self.language.as_ref()) } + pub fn language_config_at(&self, position: D) -> Option { + let offset = position.to_offset(self); + + if let Some(layer_info) = self + .syntax + .layers_for_range(offset..offset, &self.text) + .filter(|l| l.node.end_byte() > offset) + .last() + { + Some(LanguageConfigYeet { + language: layer_info.language.clone(), + override_id: layer_info.override_id(offset, &self.text), + }) + } else { + self.language.clone().map(|language| LanguageConfigYeet { + language, + override_id: None, + }) + } + } + pub fn surrounding_word(&self, start: T) -> (Range, Option) { let mut start = start.to_offset(self); let mut end = start; diff --git a/crates/language/src/language.rs b/crates/language/src/language.rs index c3f2c3716b43c208408f67218f191354fcbe0c7b..3c8b2b987b10f71f2f3a8894ae9f587bf402c958 100644 --- a/crates/language/src/language.rs +++ b/crates/language/src/language.rs @@ -22,7 +22,10 @@ use lazy_static::lazy_static; use parking_lot::{Mutex, RwLock}; use postage::watch; use regex::Regex; -use serde::{de, Deserialize, Deserializer}; +use serde::{ + de::{self}, + Deserialize, Deserializer, +}; use serde_json::Value; use std::{ any::Any, @@ -243,6 +246,45 @@ pub struct LanguageConfig { pub line_comment: Option>, #[serde(default)] pub block_comment: Option<(Arc, Arc)>, + #[serde(default)] + pub overrides: HashMap, +} + +#[derive(Clone)] +pub struct LanguageConfigYeet { + language: Arc, + override_id: Option, +} + +#[derive(Deserialize)] +pub struct LanguageConfigOverride { + #[serde(default)] + pub line_comment: Override>, + #[serde(default)] + pub block_comment: Override<(Arc, Arc)>, +} + +#[derive(Deserialize)] +#[serde(untagged)] +pub enum Override { + Remove { remove: bool }, + Set(T), +} + +impl Default for Override { + fn default() -> Self { + Override::Remove { remove: false } + } +} + +impl Override { + fn as_option<'a>(this: Option<&'a Self>, original: &'a Option) -> Option<&'a T> { + match this { + Some(Self::Set(value)) => Some(value), + Some(Self::Remove { remove: true }) => None, + Some(Self::Remove { remove: false }) | None => original.as_ref(), + } + } } impl Default for LanguageConfig { @@ -257,6 +299,7 @@ impl Default for LanguageConfig { autoclose_before: Default::default(), line_comment: Default::default(), block_comment: Default::default(), + overrides: Default::default(), } } } @@ -311,6 +354,7 @@ pub struct Grammar { pub(crate) indents_config: Option, pub(crate) outline_config: Option, pub(crate) injection_config: Option, + pub(crate) override_config: Option, pub(crate) highlight_map: Mutex, } @@ -336,6 +380,11 @@ struct InjectionConfig { patterns: Vec, } +struct OverrideConfig { + query: Query, + values: HashMap, +} + #[derive(Default, Clone)] struct InjectionPatternConfig { language: Option>, @@ -635,6 +684,7 @@ impl Language { outline_config: None, indents_config: None, injection_config: None, + override_config: None, ts_language, highlight_map: Default::default(), }) @@ -775,6 +825,25 @@ impl Language { Ok(self) } + pub fn with_override_query(mut self, source: &str) -> Result { + let query = Query::new(self.grammar_mut().ts_language, source)?; + + let mut values = HashMap::default(); + for (ix, name) in query.capture_names().iter().enumerate() { + if let Some(override_name) = name.strip_prefix("override.") { + let value = self + .config + .overrides + .remove(override_name) + .ok_or_else(|| anyhow!("no such override {override_name}"))?; + values.insert(ix as u32, value); + } + } + + self.grammar_mut().override_config = Some(OverrideConfig { query, values }); + Ok(self) + } + fn grammar_mut(&mut self) -> &mut Grammar { Arc::get_mut(self.grammar.as_mut().unwrap()).unwrap() } @@ -800,17 +869,6 @@ impl Language { self.config.name.clone() } - pub fn line_comment_prefix(&self) -> Option<&Arc> { - self.config.line_comment.as_ref() - } - - pub fn block_comment_delimiters(&self) -> Option<(&Arc, &Arc)> { - self.config - .block_comment - .as_ref() - .map(|(start, end)| (start, end)) - } - pub async fn disk_based_diagnostic_sources(&self) -> &[String] { match self.adapter.as_ref() { Some(adapter) => &adapter.disk_based_diagnostic_sources, @@ -886,10 +944,6 @@ impl Language { result } - pub fn brackets(&self) -> &[BracketPair] { - &self.config.brackets - } - pub fn path_suffixes(&self) -> &[String] { &self.config.path_suffixes } @@ -912,6 +966,43 @@ impl Language { } } +impl LanguageConfigYeet { + pub fn line_comment_prefix(&self) -> Option<&Arc> { + Override::as_option( + self.over_ride().map(|o| &o.line_comment), + &self.language.config.line_comment, + ) + } + + pub fn block_comment_delimiters(&self) -> Option<(&Arc, &Arc)> { + Override::as_option( + self.over_ride().map(|o| &o.block_comment), + &self.language.config.block_comment, + ) + .map(|e| (&e.0, &e.1)) + } + + pub fn brackets(&self) -> &[BracketPair] { + &self.language.config.brackets + } + + pub fn should_autoclose_before(&self, c: char) -> bool { + c.is_whitespace() || self.language.config.autoclose_before.contains(c) + } + + fn over_ride(&self) -> Option<&LanguageConfigOverride> { + self.override_id.and_then(|id| { + self.language + .grammar + .as_ref()? + .override_config + .as_ref()? + .values + .get(&id) + }) + } +} + impl Hash for Language { fn hash(&self, state: &mut H) { self.id().hash(state) diff --git a/crates/language/src/syntax_map.rs b/crates/language/src/syntax_map.rs index 65d01e949317bf64ab7ee65258df3c0c848e5602..458ffd8bc23a147a241ea719636e65389bdafafa 100644 --- a/crates/language/src/syntax_map.rs +++ b/crates/language/src/syntax_map.rs @@ -1127,6 +1127,41 @@ fn splice_included_ranges( ranges } +impl<'a> SyntaxLayerInfo<'a> { + pub(crate) fn override_id(&self, offset: usize, text: &text::BufferSnapshot) -> Option { + let text = TextProvider(text.as_rope()); + let config = self.language.grammar.as_ref()?.override_config.as_ref()?; + + let mut query_cursor = QueryCursorHandle::new(); + query_cursor.set_byte_range(offset..offset); + + let mut smallest_match: Option<(u32, Range)> = None; + for mat in query_cursor.matches(&config.query, self.node, text) { + for capture in mat.captures { + if !config.values.contains_key(&capture.index) { + continue; + } + + let range = capture.node.byte_range(); + if offset <= range.start || offset >= range.end { + continue; + } + + if let Some((_, smallest_range)) = &smallest_match { + if range.len() < smallest_range.len() { + smallest_match = Some((capture.index, range)) + } + continue; + } + + smallest_match = Some((capture.index, range)); + } + } + + smallest_match.map(|(index, _)| index) + } +} + impl std::ops::Deref for SyntaxMap { type Target = SyntaxSnapshot; diff --git a/crates/zed/src/languages/javascript/contexts.scm b/crates/zed/src/languages/javascript/contexts.scm new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/crates/zed/src/languages/tsx/config.toml b/crates/zed/src/languages/tsx/config.toml index 7baa12385c89d684eb80a708497d02693017eca3..4f466cc961e3836ee8d458cdcc4d863f61ab92a5 100644 --- a/crates/zed/src/languages/tsx/config.toml +++ b/crates/zed/src/languages/tsx/config.toml @@ -12,3 +12,12 @@ brackets = [ { start = "`", end = "`", close = true, newline = false }, { start = "/*", end = " */", close = true, newline = false }, ] + +[overrides.element] +line_comment = { remove = true } +block_comment = ["{/* ", " */}"] + +[overrides.string] +brackets = [ + { start = "{", end = "}", close = true, newline = true }, +] diff --git a/crates/zed/src/languages/tsx/overrides.scm b/crates/zed/src/languages/tsx/overrides.scm new file mode 100644 index 0000000000000000000000000000000000000000..aa617b30862add7e3efbdeb9a2644e0b1b28ac05 --- /dev/null +++ b/crates/zed/src/languages/tsx/overrides.scm @@ -0,0 +1,2 @@ +(jsx_element) @override.element +(string) @override.string