Struct ErrorList 

pub struct ErrorList { /* private fields */ }

The error list: an ordered set of entries plus a cursor (index) into them. :cnext / ]q walk the index (wrapping vim-style); :cc N jumps to the Nth (1-based). Empty by default.

EP.1 (2026-08-10): entries are held as per-source slices, not one flat vec, and a producer’s write replaces only its own slice. The flat view every consumer reads (Self::entries) is the concatenation in ErrorSource::PRESENTATION_ORDER, each slice keeping its producer’s own ordering.

Two producers on one untagged list is a clobber: the language server republishes on every edit-debounce, so its feed would wipe a compile run’s entries while the user walked them. Sorting the merged list instead of concatenating was rejected — producer order is information (rustc emits the root cause before the cascade).

See docs/dev/architecture/error-list.md §3.1.

Implementations

impl ErrorList

pub fn new() -> Self

pub fn set(&mut self, source: ErrorSource, entries: Vec<ErrorEntry>)

Replace source’s entries for a new run, leaving every other source’s alone.

This is the producer entry point (compilation / LSP call it via crate::editor::Editor::set_error_list). An empty entries clears just that source’s run — which is what a fresh compile with no errors means, and it must not disturb the language server’s diagnostics sitting alongside.

Resets the index to 0, which is what a new run means: the user asked for fresh results and expects to start at the top. For a refresh of an existing feed use Self::refresh — resetting there would throw a user walking entry 7 back to entry 1 every time they typed.

pub fn refresh(&mut self, source: ErrorSource, entries: Vec<ErrorEntry>)

EP.2 (2026-08-10): replace source’s entries the way a live feed does — keeping the user where they were.

The distinction from Self::set is the producer’s to declare, never inferred from the data: a language server republishing after a keystroke is a refresh, a compile run is a new run, and the two are indistinguishable by looking at the entries. Without this, the default-on diagnostic feed would make :cnext unusable — which is precisely the experience someone would set lsp.diagnostics-to-error-list = false to escape.

Re-anchoring, in order: the same entry by (path, message) (tolerant of line drift, since typing above an error moves it); else the first entry of the same path at-or-after the old line; else index 0.

pub fn entries_from(&self, source: ErrorSource) -> &[ErrorEntry]

The entries contributed by one source, or an empty slice when it has none.

pub fn sources(&self) -> Vec<ErrorSource>

Which sources currently contribute entries, in presentation order.

pub fn is_empty(&self) -> bool

pub fn entries(&self) -> &[ErrorEntry]

CM.4 (2026-07-22): read-only slice of the entries. The :copen producer clones these to build the *problems* multibuffer view.

pub fn len(&self) -> usize

pub fn index(&self) -> usize

The 0-based index the list currently points at. Meaningless (returns 0) when the list is empty.

pub fn current(&self) -> Option<&ErrorEntry>

The entry the index currently points at, or None when the list is empty.

pub fn step(&mut self, delta: i64) -> Option<&ErrorEntry>

Move the index by delta, wrapping vim-style (:cnext past the last entry wraps to the first; :cprev past the first wraps to the last), and return the entry now under the index. None only when the list is empty.

pub fn jump_to(&mut self, n: Option<usize>) -> Option<&ErrorEntry>

Jump to the nth entry (1-based, vim :cc N). n == None (bare :cc) keeps the current index and returns the current entry. An out-of-range n (0, or past the end) leaves the index unchanged and returns None.

pub fn set_index_to_matching(&mut self, path: &Path, line: u32) -> bool

CM.3b: point the index at the first entry whose (path, line) matches, returning true when one was found (index moved) and false otherwise (index unchanged). Used by the <CR>-jump in *compilation* to sync the error cursor to the entry the user jumped to. Match is on path + 0-based line only — column is ignored so a jump to a line with several column- distinct diagnostics selects the first at that line.

pub fn step_file(&mut self, delta: i64) -> Option<&ErrorEntry>

CM.7: move to the first entry of the next (delta > 0) or previous (delta < 0) file, wrapping vim-style, and return the entry now under the index. :cnextfile (delta = 1) / :cprevfile (delta = -1); a count moves that many files.

A “file” is a maximal run of consecutive entries sharing a path (compiler / tool output groups a file’s locations together; the parser preserves that order). Both directions land on the first entry of the target file — symmetric and intuitive (vim’s :cpfile technically lands on the last entry of the previous file; we deliberately land on the first so a following :cnext walks that file top-to-bottom). None only when the list is empty.

pub fn first(&mut self) -> Option<&ErrorEntry>

Jump to the first entry (:cfirst). None when empty.

pub fn last(&mut self) -> Option<&ErrorEntry>

Jump to the last entry (:clast). None when empty.

Trait Implementations

impl Clone for ErrorList

fn clone(&self) -> ErrorList

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ErrorList

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ErrorList

fn default() -> ErrorList

Returns the “default value” for a type.

impl Eq for ErrorList

impl PartialEq for ErrorList

fn eq(&self, other: &ErrorList) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for ErrorList