enum、trait 与第一份错误报告

1
impl Diagnostic {
2
    /// Creates an error with just a headline.
3
    #[must_use]
4
    pub fn error(message: impl Into<String>) -> Self {
5
        Self {
6
            severity: Severity::Error,
7
            code: None,
8
            message: message.into(),
9
            labels: Vec::new(),
10
            notes: Vec::new(),
11
        }
12
    }
13

14
    /// Creates a warning with just a headline.
15
    #[must_use]
16
    pub fn warning(message: impl Into<String>) -> Self {
17
        Self {
18
            severity: Severity::Warning,
19
            ..Self::error(message)
20
        }
21
    }

1
    /// Attaches a stable error code.
2
    #[must_use]
3
    pub fn with_code(mut self, code: impl Into<String>) -> Self {
4
        self.code = Some(code.into());
5
        self
6
    }
7

8
    /// Attaches a primary label.
9
    #[must_use]
10
    pub fn with_primary(mut self, span: Span, message: impl Into<String>) -> Self {
11
        self.labels.push(Label::primary(span, message));
12
        self
13
    }
14

15
    /// Attaches a secondary label.
16
    #[must_use]
17
    pub fn with_secondary(mut self, span: Span, message: impl Into<String>) -> Self {
18
        self.labels.push(Label::secondary(span, message));
19
        self
20
    }
21

22
    /// Attaches an unlabeled primary span.
23
    #[must_use]
24
    pub fn with_span(mut self, span: Span) -> Self {
25
        self.labels.push(Label {
26
            span,
27
            message: None,
28
            primary: true,
29
        });
30
        self
31
    }
32

33
    /// Appends a `= note:` line.
34
    #[must_use]
35
    pub fn with_note(mut self, note: impl Into<String>) -> Self {
36
        self.notes.push(note.into());
37
        self
38
    }

1
   Compiling pebble-diag v0.1.0 (/tmp/pebble-rebuild-03/crates/pebble-diag)
2
warning: unused import: `SourceMap`
3
  --> crates/pebble-diag/src/lib.rs:17:19
4
   |
5
17 | use pebble_span::{SourceMap, Span};
6
   |                   ^^^^^^^^^
7
   |
8
   = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default
9

10
warning: unused import: `Write`
11
  --> crates/pebble-diag/src/lib.rs:15:23
12
   |
13
15 | use core::fmt::{self, Write as _};
14
   |                       ^^^^^
15

16
warning: `pebble-diag` (lib) generated 2 warnings (run `cargo fix --lib -p pebble-diag` to apply 1 suggestion)
17
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.15s

1
error[E0599]: cannot write into `&mut String`
2
 --> src/bin/ch03_write_import.rs:4:12
3
  |
4
4 |     write!(out, "error[E{code:04}]")
5
  |            ^^^
6
  |
7
note: must implement `io::Write`, `fmt::Write`, or have a `write_fmt` method
8
 --> src/bin/ch03_write_import.rs:4:12
9
  |
10
4 |     write!(out, "error[E{code:04}]")
11
  |            ^^^
12
  = help: items from traits can only be used if the trait is in scope
13
help: trait `Write` which provides `write_fmt` is implemented but not in scope; perhaps you want to import it
14
  |
15
1 + use std::fmt::Write;
16
  |
17

18
For more information about this error, try `rustc --explain E0599`.
19
error: could not compile `rust-lab` (bin "ch03_write_import") due to 1 previous error

1
    /// Renders the diagnostic against a source map into a multi-line string.
2
    ///
3
    /// The output mimics the `rustc` style:
4
    ///
5
    /// ```text
6
    /// error[E0001]: unexpected token
7
    ///   --> demo.pebble:4:13
8
    ///    |
9
    ///  4 |     let x = ;
10
    ///    |             ^ expected an expression
11
    /// ```
12
    #[must_use]
13
    pub fn render(&self, sources: &SourceMap) -> String {
14
        let mut out = String::new();
15
        self.write_header(&mut out);
16

17
        // Stable order so snapshots do not depend on construction order.
18
        let mut labels: Vec<&Label> = self.labels.iter().collect();
19
        labels.sort_by_key(|label| (label.span.source, label.span.start));

1
        for label in labels {
2
            let Some(file) = sources.get(label.span.source) else {
3
                continue;
4
            };
5
            let pos = file.position(label.span.start);
6
            let line_no = pos.line;
7
            let width = digits(line_no);
8
            let pad = " ".repeat(width);
9

10
            let _ = writeln!(out, "{pad}--> {}:{}:{}", file.name(), line_no, pos.column);
11
            let _ = writeln!(out, "{pad} |");
12

13
            let line_text = file.line(line_no).unwrap_or("");
14
            let _ = writeln!(out, "{line_no:>width$} | {line_text}");
15

16
            let (caret_col, caret_len) = caret_geometry(file, label.span, line_no, line_text);
17
            let marker = if label.primary { '^' } else { '-' };
18
            let carets: String = core::iter::repeat_n(marker, caret_len).collect();
19
            let lead = " ".repeat(caret_col);
20
            match &label.message {
21
                Some(message) => {
22
                    let _ = writeln!(out, "{pad} | {lead}{carets} {message}");
23
                }
24
                None => {
25
                    let _ = writeln!(out, "{pad} | {lead}{carets}");
26
                }
27
            }
28
            let _ = writeln!(out, "{pad} |");
29
        }

1
        for note in &self.notes {
2
            let _ = writeln!(out, "  = note: {note}");
3
        }
4

5
        out
6
    }
7

8
    fn write_header(&self, out: &mut String) {
9
        let _ = write!(out, "{}", self.severity);
10
        if let Some(code) = &self.code {
11
            let _ = write!(out, "[{code}]");
12
        }
13
        let _ = writeln!(out, ": {}", self.message);
14
    }
15
}

1
/// Computes the caret start column and length, in characters, for a span.
2
fn caret_geometry(
3
    file: &pebble_span::SourceFile,
4
    span: Span,
5
    line_no: u32,
6
    line_text: &str,
7
) -> (usize, usize) {
8
    let line_start = file.line_start(line_no).unwrap_or(0);
9
    let byte_in_line = span.start.saturating_sub(line_start) as usize;
10
    let byte_in_line = byte_in_line.min(line_text.len());
11

12
    // Character columns, not byte columns, so CJK lines line up.
13
    let caret_col = line_text[..byte_in_line].chars().count();
14

15
    let line_end = line_start + line_text.len() as u32;
16
    let covered_end = span.end.min(line_end).max(span.start);
17
    let covered = (covered_end - span.start) as usize;
18
    let slice_end = (byte_in_line + covered).min(line_text.len());
19
    let caret_len = line_text[byte_in_line..slice_end].chars().count().max(1);
20

21
    (caret_col, caret_len)
22
}

1
#[cfg(test)]
2
mod tests {
3
    use super::*;
4

5
    #[test]
6
    fn renders_a_single_caret_line() {
7
        let mut sources = SourceMap::new();
8
        let id = sources.add("demo.pebble", "let x = 1;\nlet y = ;\n");
9
        let span = Span::new(id, 19, 19);
10
        let diag = Diagnostic::error("expected an expression")
11
            .with_code("E0001")
12
            .with_primary(span, "found `;`");
13

14
        let rendered = diag.render(&sources);
15
        assert!(
16
            rendered.starts_with("error[E0001]: expected an expression\n"),
17
            "header must be on its own line:\n{rendered}"
18
        );
19
        assert!(rendered.contains("--> demo.pebble:2:9"));
20
        assert!(rendered.contains("^ found `;`"));
21
    }
22

23
    #[test]
24
    fn caret_length_tracks_span_length() {
25
        let mut sources = SourceMap::new();
26
        let id = sources.add("demo.pebble", "let abcdef = 1;\n");
27
        // Span covering `abcdef` (bytes 4..10).
28
        let diag = Diagnostic::error("bad name").with_span(Span::new(id, 4, 10));
29
        let rendered = diag.render(&sources);
30
        assert!(rendered.contains("^^^^^^"), "got:\n{rendered}");
31
    }
32

33
    #[test]
34
    fn notes_are_rendered() {
35
        let mut sources = SourceMap::new();
36
        let id = sources.add("demo.pebble", "x\n");
37
        let diag = Diagnostic::error("nope")
38
            .with_span(Span::new(id, 0, 1))
39
            .with_note("did you mean `y`?");
40
        assert!(diag.render(&sources).contains("= note: did you mean `y`?"));
41
    }

1
use pebble_diag::Diagnostic;
2
use pebble_span::{SourceMap, Span};
3

4
fn main() {
5
    let mut sources = SourceMap::new();
6
    let id = sources.add("demo.pebble", "let a = 1;\nlet b = a + c;\n");
7
    let diag = Diagnostic::error("undefined variable `c`")
8
        .with_code("E0100")
9
        .with_primary(Span::new(id, 23, 24), "not found in this scope")
10
        .with_secondary(Span::new(id, 4, 5), "`a` is defined here")
11
        .with_note("variables must be declared with `let`");
12
    print!("{}", diag.render(&sources));
13
    println!("---");
14
    println!("{diag}");
15
    println!("{diag:?}");
16
}

1
error[E0277]: `Oops` doesn't implement `Debug`
2
  --> src/bin/ch03_supertrait.rs:11:28
3
   |
4
11 | impl std::error::Error for Oops {}
5
   |                            ^^^^ the trait `Debug` is not implemented for `Oops`
6
   |
7
   = note: add `#[derive(Debug)]` to `Oops` or manually `impl Debug for Oops`
8
note: required by a bound in `std::error::Error`
9
  --> /rustc/59807616e1fa2540724bfbac14d7976d7e4a3860/library/core/src/error.rs:59:0
10
help: consider annotating `Oops` with `#[derive(Debug)]`
11
   |
12
 3 + #[derive(Debug)]
13
 4 | struct Oops;
14
   |
15

16
For more information about this error, try `rustc --explain E0277`.
17
error: could not compile `rust-lab` (bin "ch03_supertrait") due to 1 previous error

1
error[E0100]: undefined variable `c`
2
 --> demo.pebble:1:5
3
  |
4
1 | let a = 1;
5
  |     - `a` is defined here
6
  |
7
 --> demo.pebble:2:13
8
  |
9
2 | let b = a + c;
10
  |             ^ not found in this scope
11
  |
12
  = note: variables must be declared with `let`
13
---
14
error[E0100]: undefined variable `c`
15
Diagnostic { severity: Error, code: Some("E0100"), message: "undefined variable `c`", labels: [Label { span: 23..24, message: Some("not found in this scope"), primary: true }, Label { span: 4..5, message: Some("`a` is defined here"), primary: false }], notes: ["variables must be declared with `let`"] }

1
error[E0038]: the trait `Sink` is not dyn compatible
2
  --> src/bin/ch03_sink_dyn.rs:16:27
3
   |
4
16 |     let mut sink: Box<dyn Sink> = Box::new(Vec::new());
5
   |                           ^^^^ `Sink` is not dyn compatible
6
   |
7
note: for a trait to be dyn compatible it needs to allow building a vtable
8
      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
9
  --> src/bin/ch03_sink_dyn.rs:4:8
10
   |
11
 1 | trait Sink {
12
   |       ---- this trait is not dyn compatible...
13
...
14
 4 |     fn error(&mut self, message: impl Into<String>) {
15
   |        ^^^^^ ...because method `error` has generic type parameters
16
   = help: consider moving `error` to another trait
17
   = help: only type `std::vec::Vec<std::string::String>` implements `Sink`; consider using it directly instead.
18

19
For more information about this error, try `rustc --explain E0038`.
20
error: could not compile `rust-lab` (bin "ch03_sink_dyn") due to 1 previous error