Error Highlighting Showcase

Point to the field name when it's unknown or unexpected.

#[derive(Facet)]
struct Config {
    name: String,
    max_retries: u8,
    timeout_ms: u32,
    enabled: bool,
}

  × unknown field `max_retries`
   ╭─[target type:4:5]
 3 │     name: String,
 4 │     max_retries: u8,
   ·     ─────┬─────
   ·          ╰── not expected here
 5 │     timeout_ms: u32,
   ╰────

Point to the type when the value doesn't match.

#[derive(Facet)]
struct Config {
    name: String,
    max_retries: u8,
    timeout_ms: u32,
    enabled: bool,
}

  × value 1000 is out of range for u8
   ╭─[target type:4:18]
 3 │     name: String,
 4 │     max_retries: u8,
   ·                  ─┬
   ·                   ╰── expected 0..255
 5 │     timeout_ms: u32,
   ╰────

Point to both name and type for context.

#[derive(Facet)]
struct Config {
    name: String,
    max_retries: u8,
    timeout_ms: u32,
    enabled: bool,
}

  × missing required field
   ╭─[target type:5:5]
 4 │     max_retries: u8,
 5 │     timeout_ms: u32,
   ·     ───────┬───────
   ·            ╰── this field is required
 6 │     enabled: bool,
   ╰────

Highlight a field inside a nested struct.

#[derive(Facet)]
struct Employee {
    person: Person,
    address: Address,
    tags: Vec<String>,
    metadata: HashMap<String, i32>,
}
#[derive(Facet)]
struct Address {
    street: String,
    city: String,
    zip: String,
}
#[derive(Facet)]
struct Person {
    name: String,
    age: u8,
    email: Option<String>,
}

  × invalid person data
   ╭─[target type:3:13]
 2 │ struct Employee {
 3 │     person: Person,
   ·             ───┬──
   ·                ╰── expected valid Person
 4 │     address: Address,
   ╰────

Highlight a deeply nested field path.

#[derive(Facet)]
struct Employee {
    person: Person,
    address: Address,
    tags: Vec<String>,
    metadata: HashMap<String, i32>,
}
#[derive(Facet)]
struct Address {
    street: String,
    city: String,
    zip: String,
}
#[derive(Facet)]
struct Person {
    name: String,
    age: u8,
    email: Option<String>,
}

  × address validation failed
   ╭─[target type:4:5]
 3 │     person: Person,
 4 │     address: Address,
   ·     ────────┬───────
   ·             ╰── city is required
 5 │     tags: Vec<String>,
   ╰────

Highlight an enum variant name.

#[derive(Facet)]
#[repr(u8)]
enum Status {
    Active,
    Pending,
    Error {
        code: i32,
        message: String,
    },
}

  × invalid variant
   ╭─[target type:4:5]
 3 │ enum Status {
 4 │     Active,
   ·     ───┬──
   ·        ╰── not allowed in this context
 5 │     Pending,
   ╰────

Highlight a tuple variant.

#[derive(Facet)]
#[repr(u8)]
enum Message {
    Text(String),
    Number(i32),
    Pair(String, i32),
    Data {
        id: u64,
        payload: Vec<u8>,
    },
}

  × type mismatch
   ╭─[target type:4:10]
 3 │ enum Message {
 4 │     Text(String),
   ·          ───┬───
   ·             ╰── expected Number, got Text
 5 │     Number(i32),
   ╰────

Highlight a field inside a struct variant.

#[derive(Facet)]
#[repr(u8)]
enum Status {
    Active,
    Pending,
    Error {
        code: i32,
        message: String,
    },
}

  × error code out of range
   ╭─[target type:7:15]
 6 │     Error {
 7 │         code: i32,
   ·               ─┬─
   ·                ╰── must be positive
 8 │         message: String,
   ╰────

Highlight a Vec field type.

#[derive(Facet)]
struct Employee {
    person: Person,
    address: Address,
    tags: Vec<String>,
    metadata: HashMap<String, i32>,
}
#[derive(Facet)]
struct Address {
    street: String,
    city: String,
    zip: String,
}
#[derive(Facet)]
struct Person {
    name: String,
    age: u8,
    email: Option<String>,
}

  × invalid tags
   ╭─[target type:5:11]
 4 │     address: Address,
 5 │     tags: Vec<String>,
   ·           ─────┬─────
   ·                ╰── expected array of strings
 6 │     metadata: HashMap<String, i32>,
   ╰────

Highlight an Option field.

#[derive(Facet)]
struct Person {
    name: String,
    age: u8,
    email: Option<String>,
}

  × invalid email format
   ╭─[target type:5:5]
 4 │     age: u8,
 5 │     email: Option<String>,
   ·     ──────────┬──────────
   ·               ╰── must be a valid email address
 6 │ }
   ╰────

Highlight a HashMap field.

#[derive(Facet)]
struct Employee {
    person: Person,
    address: Address,
    tags: Vec<String>,
    metadata: HashMap<String, i32>,
}
#[derive(Facet)]
struct Address {
    street: String,
    city: String,
    zip: String,
}
#[derive(Facet)]
struct Person {
    name: String,
    age: u8,
    email: Option<String>,
}

  × invalid metadata
   ╭─[target type:6:15]
 5 │     tags: Vec<String>,
 6 │     metadata: HashMap<String, i32>,
   ·               ──────────┬─────────
   ·                         ╰── keys must be alphanumeric
 7 │ }
   ╰────