Yehowshua/ZIm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Add lsp_settings_changed: Task to Project, need to resolve cx in Project::on_settings_changed

Browse source
This commit is contained in:
Isaac Clayton 2022-07-04 18:25:05 +02:00
parent f4b4212932
commit 7d128e81aa
2 changed files with 162 additions and 99 deletions
Download patch file Download diff file Expand all files Collapse all files

2
crates/language/src/proto.rs
View file

@ -399,7 +399,7 @@ pub fn serialize_completion(completion: &Completion) -> proto::Completion {
pub async fn deserialize_completion( pub async fn deserialize_completion(
completion: proto::Completion, completion: proto::Completion,
language: Option<&Arc<Language>>, language: Option<Arc<Language>>,
) -> Result<Completion> { ) -> Result<Completion> {
let old_start = completion let old_start = completion
.old_start .old_start

259
crates/project/src/project.rs
View file

@ -113,6 +113,7 @@ pub struct Project {
collaborators: HashMap<PeerId, Collaborator>, collaborators: HashMap<PeerId, Collaborator>,
client_subscriptions: Vec<client::Subscription>, client_subscriptions: Vec<client::Subscription>,
_subscriptions: Vec<gpui::Subscription>, _subscriptions: Vec<gpui::Subscription>,
lsp_settings_changed: Option<Task<()>>,
opened_buffer: (Rc<RefCell<watch::Sender<()>>>, watch::Receiver<()>), opened_buffer: (Rc<RefCell<watch::Sender<()>>>, watch::Receiver<()>),
shared_buffers: HashMap<PeerId, HashSet<u64>>, shared_buffers: HashMap<PeerId, HashSet<u64>>,
loading_buffers: HashMap< loading_buffers: HashMap<
@ -488,6 +489,7 @@ impl Project {
next_language_server_id: 0, next_language_server_id: 0,
nonce: StdRng::from_entropy().gen(), nonce: StdRng::from_entropy().gen(),
initialized_persistent_state: false, initialized_persistent_state: false,
lsp_settings_changed: None,
} }
}) })
} }
@ -602,6 +604,7 @@ impl Project {
buffer_snapshots: Default::default(), buffer_snapshots: Default::default(),
nonce: StdRng::from_entropy().gen(), nonce: StdRng::from_entropy().gen(),
initialized_persistent_state: false, initialized_persistent_state: false,
lsp_settings_changed: None,
}; };
for worktree in worktrees { for worktree in worktrees {
this.add_worktree(&worktree, cx); this.add_worktree(&worktree, cx);
@ -710,51 +713,55 @@ impl Project {
fn on_settings_changed(&mut self, cx: &mut ModelContext<'_, Self>) { fn on_settings_changed(&mut self, cx: &mut ModelContext<'_, Self>) {
let settings = cx.global::<Settings>(); let settings = cx.global::<Settings>();
self.lsp_settings_changed = Some(cx.spawn(|_, _| async {
let mut language_servers_to_start = Vec::new(); let mut language_servers_to_start = Vec::new();
for buffer in self.opened_buffers.values() { for buffer in self.opened_buffers.values() {
if let Some(buffer) = buffer.upgrade(cx) { if let Some(buffer) = buffer.upgrade(cx) {
let buffer = buffer.read(cx); let buffer = buffer.read(cx);
if let Some((file, language)) = File::from_dyn(buffer.file()).zip(buffer.language()) if let Some((file, language)) =
{ File::from_dyn(buffer.file()).zip(buffer.language())
if settings.enable_language_server(Some(&language.name())) { {
let worktree = file.worktree.read(cx); if settings.enable_language_server(Some(&language.name())) {
language_servers_to_start.push(( let worktree = file.worktree.read(cx);
worktree.id(), language_servers_to_start.push((
worktree.as_local().unwrap().abs_path().clone(), worktree.id(),
language.clone(), worktree.as_local().unwrap().abs_path().clone(),
)); language.clone(),
} ));
}
}
}
let mut language_servers_to_stop = Vec::new();
for language in self.languages.to_vec() {
if let Some(lsp_adapter) = language.lsp_adapter() {
if !settings.enable_language_server(Some(&language.name())) {
let lsp_name = lsp_adapter.name().await;
for (worktree_id, started_lsp_name) in self.started_language_servers.keys() {
if lsp_name == *started_lsp_name {
language_servers_to_stop.push((*worktree_id, started_lsp_name.clone()));
} }
} }
} }
} }
}
// Stop all newly-disabled language servers. let mut language_servers_to_stop = Vec::new();
for (worktree_id, adapter_name) in language_servers_to_stop { for language in self.languages.to_vec() {
self.stop_language_server(worktree_id, adapter_name, cx) if let Some(lsp_adapter) = language.lsp_adapter() {
.detach(); if !settings.enable_language_server(Some(&language.name())) {
} let lsp_name = lsp_adapter.name().await;
for (worktree_id, started_lsp_name) in self.started_language_servers.keys()
{
if lsp_name == *started_lsp_name {
language_servers_to_stop
.push((*worktree_id, started_lsp_name.clone()));
}
}
}
}
}
// Start all the newly-enabled language servers. // Stop all newly-disabled language servers.
for (worktree_id, worktree_path, language) in language_servers_to_start { for (worktree_id, adapter_name) in language_servers_to_stop {
self.start_language_server(worktree_id, worktree_path, language, cx); self.stop_language_server(worktree_id, adapter_name, cx)
} .detach();
}
cx.notify(); // Start all the newly-enabled language servers.
for (worktree_id, worktree_path, language) in language_servers_to_start {
self.start_language_server(worktree_id, worktree_path, language, cx);
}
cx.notify();
}))
} }
pub fn buffer_for_id(&self, remote_id: u64, cx: &AppContext) -> Option<ModelHandle<Buffer>> { pub fn buffer_for_id(&self, remote_id: u64, cx: &AppContext) -> Option<ModelHandle<Buffer>> {
@ -3482,19 +3489,18 @@ impl Project {
let snapshot = this.snapshot(); let snapshot = this.snapshot();
let clipped_position = this.clip_point_utf16(position, Bias::Left); let clipped_position = this.clip_point_utf16(position, Bias::Left);
let mut range_for_token = None; let mut range_for_token = None;
Ok(completions let result = Vec::new();
.into_iter()
.filter_map(|lsp_completion| {
// For now, we can only handle additional edits if they are returned
// when resolving the completion, not if they are present initially.
if lsp_completion
.additional_text_edits
.as_ref()
.map_or(false, |edits| !edits.is_empty())
{
return None;
}
for lsp_completion in completions.into_iter() {
// For now, we can only handle additional edits if they are returned
// when resolving the completion, not if they are present initially.
if lsp_completion
.additional_text_edits
.as_ref()
.map_or(false, |edits| !edits.is_empty())
{
continue;
}
let (old_range, mut new_text) = match lsp_completion.text_edit.as_ref() let (old_range, mut new_text) = match lsp_completion.text_edit.as_ref()
{ {
// If the language server provides a range to overwrite, then // If the language server provides a range to overwrite, then
@ -3540,9 +3546,17 @@ impl Project {
text.clone(), text.clone(),
) )
} }
Some(lsp::CompletionTextEdit::InsertAndReplace(_)) => { (
log::info!("unsupported insert/replace completion"); snapshot.anchor_before(start)..snapshot.anchor_after(end),
return None; edit.new_text.clone(),
)
}
// If the language server does not provide a range, then infer
// the range based on the syntax tree.
None => {
if position != clipped_position {
log::info!("completion out of expected range");
continue;
} }
}; };
@ -3560,12 +3574,54 @@ impl Project {
lsp_completion.label.clone(), lsp_completion.label.clone(),
lsp_completion.filter_text.as_deref(), lsp_completion.filter_text.as_deref(),
) )
let Range { start, end } = range_for_token
.get_or_insert_with(|| {
let offset = position.to_offset(&snapshot);
let (range, kind) = snapshot.surrounding_word(offset);
if kind == Some(CharKind::Word) {
range
} else {
offset..offset
}
}) })
}, .clone();
lsp_completion, let text = lsp_completion
}) .insert_text
}) .as_ref()
.collect()) .unwrap_or(&lsp_completion.label)
.clone();
(
snapshot.anchor_before(start)..snapshot.anchor_after(end),
text.clone(),
)
}
Some(lsp::CompletionTextEdit::InsertAndReplace(_)) => {
log::info!("unsupported insert/replace completion");
continue;
}
};
let completion = Completion {
old_range,
new_text,
label: {
match language.as_ref() {
Some(l) => l.label_for_completion(&lsp_completion).await,
None => None,
}
.unwrap_or_else(|| {
CodeLabel::plain(
lsp_completion.label.clone(),
lsp_completion.filter_text.as_deref(),
)
})
},
lsp_completion,
};
result.push(completion);
}
Ok(result)
}) })
}) })
} else if let Some(project_id) = self.remote_id() { } else if let Some(project_id) = self.remote_id() {
@ -3587,10 +3643,8 @@ impl Project {
let completions = Vec::new(); let completions = Vec::new();
for completion in response.completions.into_iter() { for completion in response.completions.into_iter() {
completions.push( completions
language::proto::deserialize_completion(completion, language.as_ref()) .push(language::proto::deserialize_completion(completion, language).await);
.await,
);
} }
completions.into_iter().collect() completions.into_iter().collect()
}) })
@ -5205,7 +5259,7 @@ impl Project {
.payload .payload
.completion .completion
.ok_or_else(|| anyhow!("invalid completion"))?, .ok_or_else(|| anyhow!("invalid completion"))?,
language, language.cloned(),
); );
Ok::<_, anyhow::Error>((buffer, completion)) Ok::<_, anyhow::Error>((buffer, completion))
})?; })?;
@ -5605,43 +5659,52 @@ impl Project {
}) })
} }
async fn deserialize_symbol(&self, serialized_symbol: proto::Symbol) -> Result<Symbol> { fn deserialize_symbol(
let source_worktree_id = WorktreeId::from_proto(serialized_symbol.source_worktree_id); &self,
let worktree_id = WorktreeId::from_proto(serialized_symbol.worktree_id); serialized_symbol: proto::Symbol,
let start = serialized_symbol ) -> impl Future<Output = Result<Symbol>> {
.start let languages = self.languages.clone();
.ok_or_else(|| anyhow!("invalid start"))?; async move {
let end = serialized_symbol let source_worktree_id = WorktreeId::from_proto(serialized_symbol.source_worktree_id);
.end let worktree_id = WorktreeId::from_proto(serialized_symbol.worktree_id);
.ok_or_else(|| anyhow!("invalid end"))?; let start = serialized_symbol
let kind = unsafe { mem::transmute(serialized_symbol.kind) }; .start
let path = PathBuf::from(serialized_symbol.path); .ok_or_else(|| anyhow!("invalid start"))?;
let language = self.languages.select_language(&path); let end = serialized_symbol
Ok(Symbol { .end
source_worktree_id, .ok_or_else(|| anyhow!("invalid end"))?;
worktree_id, let kind = unsafe { mem::transmute(serialized_symbol.kind) };
language_server_name: LanguageServerName(serialized_symbol.language_server_name.into()), let path = PathBuf::from(serialized_symbol.path);
label: { let language = languages.select_language(&path);
match language { Ok(Symbol {
Some(language) => { source_worktree_id,
language worktree_id,
.label_for_symbol(&serialized_symbol.name, kind) language_server_name: LanguageServerName(
.await serialized_symbol.language_server_name.into(),
),
label: {
match language {
Some(language) => {
language
.label_for_symbol(&serialized_symbol.name, kind)
.await
}
None => None,
} }
None => None, .unwrap_or_else(|| CodeLabel::plain(serialized_symbol.name.clone(), None))
} },
.unwrap_or_else(|| CodeLabel::plain(serialized_symbol.name.clone(), None))
},
name: serialized_symbol.name, name: serialized_symbol.name,
path, path,
range: PointUtf16::new(start.row, start.column)..PointUtf16::new(end.row, end.column), range: PointUtf16::new(start.row, start.column)
kind, ..PointUtf16::new(end.row, end.column),
signature: serialized_symbol kind,
.signature signature: serialized_symbol
.try_into() .signature
.map_err(|_| anyhow!("invalid signature"))?, .try_into()
}) .map_err(|_| anyhow!("invalid signature"))?,
})
}
} }
async fn handle_buffer_saved( async fn handle_buffer_saved(