+ diagnostic::DiagnosticProvider,

+ self, DocumentOpenError, DocumentSavedEventFuture, DocumentSavedEventResult, Mode,

+ SavePoint,

+ events::{DiagnosticsDidChange, DocumentDidClose, DocumentDidOpen, DocumentFocusLost},

+ Diagnostic, Document, DocumentId, View, ViewId,

+use dap::StackFrame;

+use parking_lot::RwLock;

+ num::NonZeroU8,

+ Change, LineEnding, Position, Range, Selection, SpellingLanguage, Uri, NATIVE_LINE_ENDING,

+use helix_dap as dap;

+ end_of_line_diagnostics: DiagnosticFilter::Disable,

+type Diagnostics = BTreeMap<Uri, Vec<Diagnostic>>;

+ pub debugger: Option<dap::Client>,

+ pub debugger_events: SelectAll<UnboundedReceiverStream<dap::Payload>>,

+

+ pub dictionaries: Dictionaries,

+type Dictionaries = HashMap<SpellingLanguage, Arc<RwLock<spellbook::Dictionary>>>;

+

+ DebuggerEvent(dap::Payload),

+ debugger: None,

+ debugger_events: SelectAll::new(),

+ dictionaries: HashMap::new(),

+ pub fn refresh_config(&mut self) {

+ .map_or(true, |ls| ls.id() != doc_ls.id())

+ .map_or(true, |doc_ls| ls.id() != doc_ls.id())

+ self.next_document_id = self.next_document_id.next();

+ let (stdin, encoding, has_bom) = document::read_to_string(&mut stdin(), None)?;

+ let prev_id = std::mem::replace(&mut self.tree.focus, view_id);

+ // if leaving the view: mode should reset and the cursor should be

+ // within view

+ if prev_id != view_id {

+ self.enter_normal_mode();

+ self.ensure_cursor_in_view(view_id);

+

+ // Update jumplist selections with new document changes.

+ for (view, _focused) in self.tree.views_mut() {

+ let doc = doc_mut!(self, &view.doc);

+ view.sync_changes(doc);

+ }

+ let view = view!(self, view_id);

+ doc.mark_as_focused();

+ let focus_lost = self.tree.get(prev_id).doc;

+ dispatch(DocumentFocusLost {

+ editor: self,

+ doc: focus_lost,

+ });

+ ) -> impl Iterator<Item = document::Diagnostic> + 'a {

+ Editor::doc_diagnostics_with_filter(language_servers, diagnostics, document, |_| true)

+ filter: impl Fn(&Diagnostic) -> bool + 'a,

+ ) -> impl Iterator<Item = document::Diagnostic> + 'a {

+ diagnostics

+ .get(&document.uri())

+ diags.iter().filter_map(move |diagnostic| {

+ let language_server = diagnostic

+ .provider

+ .language_server_id()

+ .and_then(|id| language_servers.get_by_id(id));

+

+ if let Some((config, server)) = language_config.as_ref().zip(language_server) {

+ config.language_servers.iter().find(|features| {

+ features.name == server.name()

+ && features.has_feature(LanguageServerFeature::Diagnostics)

+ })?;

+ }

+ if diagnostic.severity.is_some_and(|severity| {

+ language_config

+ .as_ref()

+ .is_some_and(|config| severity < config.diagnostic_severity)

+ }) {

+ return None;

+ }

+

+ if filter(diagnostic) {

+ diagnostic.to_document_diagnostic(&text)

+ } else {

+ None

+ }

+ Some(event) = self.debugger_events.next() => {

+ pub fn current_stack_frame(&self) -> Option<&StackFrame> {

+ self.debugger

+ .as_ref()

+ .and_then(|debugger| debugger.current_stack_frame())

+

+ pub fn handle_diagnostics(

+ &mut self,

+ provider: &DiagnosticProvider,

+ uri: Uri,

+ version: Option<i32>,

+ mut diagnostics: Vec<Diagnostic>,

+ ) {

+ use std::collections::btree_map::Entry;

+

+ let doc = self.documents.values_mut().find(|doc| doc.uri() == uri);

+

+ if let Some((version, doc)) = version.zip(doc.as_ref()) {

+ if version != doc.version() {

+ log::info!("Version ({version}) is out of date for {uri:?} (expected ({})), dropping diagnostics", doc.version());

+ return;

+ }

+ }

+

+ let mut unchanged_diag_sources = Vec::new();

+ if let Some((lang_conf, old_diagnostics)) = doc

+ .as_ref()

+ .and_then(|doc| Some((doc.language_config()?, self.diagnostics.get(&uri)?)))

+ {

+ if !lang_conf.persistent_diagnostic_sources.is_empty() {

+ diagnostics.sort();

+ }

+ for source in &lang_conf.persistent_diagnostic_sources {

+ let new_diagnostics = diagnostics

+ .iter()

+ .filter(|d| d.source.as_ref() == Some(source));

+ let old_diagnostics = old_diagnostics

+ .iter()

+ .filter(|d| &d.provider == provider && d.source.as_ref() == Some(source));

+ if new_diagnostics.eq(old_diagnostics) {

+ unchanged_diag_sources.push(source.clone())

+ }

+ }

+ }

+

+ // Insert the original lsp::Diagnostics here because we may have no open document

+ // for diagnostic message and so we can't calculate the exact position.

+ // When using them later in the diagnostics picker, we calculate them on-demand.

+ let diagnostics = match self.diagnostics.entry(uri) {

+ Entry::Occupied(o) => {

+ let current_diagnostics = o.into_mut();

+ // there may entries of other language servers, which is why we can't overwrite the whole entry

+ current_diagnostics.retain(|diagnostic| &diagnostic.provider != provider);

+ current_diagnostics.extend(diagnostics);

+ current_diagnostics

+ // Sort diagnostics first by severity and then by line numbers.

+ }

+ Entry::Vacant(v) => v.insert(diagnostics),

+ };

+

+ diagnostics.sort();

+

+ if let Some(doc) = doc {

+ let diagnostic_of_language_server_and_not_in_unchanged_sources =

+ |diagnostic: &crate::Diagnostic| {

+ &diagnostic.provider == provider

+ && diagnostic

+ .source

+ .as_ref()

+ .map_or(true, |source| !unchanged_diag_sources.contains(source))

+ };

+ let diagnostics = Self::doc_diagnostics_with_filter(

+ &self.language_servers,

+ &self.diagnostics,

+ doc,

+ diagnostic_of_language_server_and_not_in_unchanged_sources,

+ );

+ doc.replace_diagnostics(diagnostics, &unchanged_diag_sources, Some(provider));

+

+ let doc = doc.id();

+ helix_event::dispatch(DiagnosticsDidChange { editor: self, doc });

+ }

+ }