Ariadne

https://github.com/zesterer/ariadne
Admin
Ariadne is a Rust crate that provides fancy and highly customizable compiler diagnostics, enabling...
Tokens:8,652
Snippets:48
Trust Score:9.9
License:MIT
Update:1 month ago
Show doc for...
Tokens:
Raw
### TOML: Enabling Ariadne's Auto-Color Feature

Source: https://github.com/zesterer/ariadne/blob/main/README.md

This TOML snippet shows how to configure Ariadne's dependencies to enable automatic color output detection using the 'concolor' crate. This is a convenience feature that simplifies the setup for color support in the terminal.

```TOML
[dependencies]
ariadne = { version = "...", features = ["auto-color"] }
```

--------------------------------

### Create a Diagnostic Report with Report::build

Source: https://context7.com/zesterer/ariadne/llms.txt

Demonstrates how to initiate a diagnostic report using the builder pattern. It shows how to define the report kind, primary span, and attach labels with messages to source code.

```rust
use ariadne::{Report, ReportKind, Label, Source};

fn main() {
    Report::build(ReportKind::Error, 34..34)
        .with_message("Incompatible types")
        .with_label(Label::new(32..33).with_message("This is of type Nat"))
        .with_label(Label::new(52..55).with_message("This is of type Str"))
        .finish()
        .print(Source::from("let x = match true { true => 1, false => \"hello\" }; print(x)"))
        .unwrap();
}
```

--------------------------------

### Configure Source Code Labels with Label::new

Source: https://context7.com/zesterer/ariadne/llms.txt

Shows how to create and customize labels for source code diagnostics. This includes setting colors, display priorities, and ordering to manage how labels appear in the final output.

```rust
use ariadne::{Report, ReportKind, Label, Source, Color};

fn main() {
    let source = "fn add(a: i32, b: str) -> i32 { a + b }";

    Report::build(ReportKind::Error, 16..19)
        .with_message("Type mismatch in function parameters")
        .with_label(
            Label::new(10..13)
                .with_message("Expected i32")
                .with_color(Color::Blue)
        )
        .with_label(
            Label::new(16..19)
                .with_message("Found str")
                .with_color(Color::Red)
                .with_priority(1)
        )
        .with_label(
            Label::new(32..37)
                .with_message("Addition requires matching types")
                .with_color(Color::Yellow)
                .with_order(10)
        )
        .finish()
        .print(Source::from(source))
        .unwrap();
}
```

--------------------------------

### Implement Source Caching with Ariadne

Source: https://context7.com/zesterer/ariadne/llms.txt

Demonstrates three ways to handle source file caching: FileCache for filesystem access, FnCache for custom fetch logic, and sources() for inline data. These caches are required to resolve source content during report generation.

```rust
use ariadne::{Report, ReportKind, Label, Source, Cache, FileCache, FnCache, sources};
use std::path::Path;

fn main() {
    let mut cache = FileCache::default();

    Report::build(ReportKind::Error, (Path::new("src/main.rs"), 10..20))
        .with_message("Syntax error")
        .with_label(Label::new((Path::new("src/main.rs"), 10..20)).with_message("Invalid token"))
        .finish()
        .eprint(&mut cache)
        .unwrap();

    let mut fn_cache = FnCache::new(|id: &str| -> Result<String, String> {
        match id {
            "virtual://test.rs" => Ok("fn main() { println!(\"Hello\"); }".to_string()),
            _ => Err(format!("Unknown source: {}", id)),
        }
    });

    Report::build(ReportKind::Error, ("virtual://test.rs", 12..19))
        .with_message("Type error")
        .with_label(Label::new(("virtual://test.rs", 12..19)).with_message("Expected &str"))
        .finish()
        .eprint(&mut fn_cache)
        .unwrap();

    let cache = sources([
        ("file1.rs", "use crate::foo;"),
        ("file2.rs", "pub mod foo { pub fn bar() {} }"),
    ]);

    Report::build(ReportKind::Warning, ("file1.rs", 4..14))
        .with_message("Unused import")
        .with_label(Label::new(("file1.rs", 4..14)).with_message("This import is never used"))
        .with_label(Label::new(("file2.rs", 18..21)).with_message("Defined here"))
        .finish()
        .print(cache)
        .unwrap();
}
```

--------------------------------

### Cache Trait and FileCache

Source: https://context7.com/zesterer/ariadne/llms.txt

Demonstrates the usage of the Cache trait, FileCache for filesystem caching, FnCache for custom fetch logic, and the sources() helper for inline multi-file diagnostics.

```APIDOC
## Cache Trait and FileCache - Source File Management

The `Cache` trait abstracts source file storage and retrieval. `FileCache` provides automatic filesystem-based caching, while `FnCache` allows custom fetch functions. For simple cases, tuples and the `sources()` helper can create caches inline. Caches handle source file lookup, caching, and display name generation.

### Example Usage

```rust
use ariadne::{Report, ReportKind, Label, Source, Cache, FileCache, FnCache, sources};
use std::path::Path;

fn main() {
    // Using FileCache for automatic file loading
    let mut cache = FileCache::default();

    Report::build(ReportKind::Error, (Path::new("src/main.rs"), 10..20))
        .with_message("Syntax error")
        .with_label(Label::new((Path::new("src/main.rs"), 10..20)).with_message("Invalid token"))
        .finish()
        .eprint(&mut cache)
        .unwrap();

    // Using FnCache with custom fetch function
    let mut fn_cache = FnCache::new(|id: &str| -> Result<String, String> {
        match id {
            "virtual://test.rs" => Ok("fn main() { println!(\"Hello\"); }".to_string()),
            _ => Err(format!("Unknown source: {}", id)),
        }
    });

    Report::build(ReportKind::Error, ("virtual://test.rs", 12..19))
        .with_message("Type error")
        .with_label(Label::new(("virtual://test.rs", 12..19)).with_message("Expected &str"))
        .finish()
        .eprint(&mut fn_cache)
        .unwrap();

    // Using sources() for inline multi-file diagnostics
    let cache = sources([
        ("file1.rs", "use crate::foo;"),
        ("file2.rs", "pub mod foo { pub fn bar() {}"},
    ]);

    Report::build(ReportKind::Warning, ("file1.rs", 4..14))
        .with_message("Unused import")
        .with_label(Label::new(("file1.rs", 4..14)).with_message("This import is never used"))
        .with_label(Label::new(("file2.rs", 18..21)).with_message("Defined here"))
        .finish()
        .print(cache)
        .unwrap();
}
```
```

--------------------------------

### Output Methods: print, eprint, and write

Source: https://context7.com/zesterer/ariadne/llms.txt

Demonstrates the usage of `print()`, `eprint()`, and `write()` for outputting Ariadne reports to different destinations.

```APIDOC
## Output Methods - print, eprint, and write

Reports can be output using `print()` for stdout, `eprint()` for stderr (recommended for diagnostics), or `write()` for any `Write` implementor. The `write_for_stdout()` variant is available when using the `concolor` feature for proper color detection.

### Method

Demonstrates the usage of `print()`, `eprint()`, and `write()` for outputting Ariadne reports.

### Endpoint

N/A (This is a library usage example, not an API endpoint)

### Parameters

N/A

### Request Example

```rust
use ariadne::{Report, ReportKind, Label, Source};
use std::io::Write;

fn main() {
    let source = Source::from("let x = 10;");

    // Print to stdout
    Report::build(ReportKind::Advice, 4..5)
        .with_message("Consider using a more descriptive name")
        .with_label(Label::new(4..5).with_message("Rename this variable"))
        .finish()
        .print(source.clone())
        .unwrap();

    // Print to stderr (preferred for diagnostics)
    Report::build(ReportKind::Error, 4..5)
        .with_message("Undefined variable")
        .with_label(Label::new(4..5).with_message("'x' not found"))
        .finish()
        .eprint(source.clone())
        .unwrap();

    // Write to a custom destination (file, buffer, etc.)
    let mut buffer = Vec::new();
    Report::build(ReportKind::Warning, 8..10)
        .with_message("Magic number detected")
        .with_label(Label::new(8..10).with_message("Consider using a named constant"))
        .finish()
        .write(source, &mut buffer)
        .unwrap();

    // buffer now contains the diagnostic output
    let output = String::from_utf8(buffer).unwrap();
    println!("Captured output:\n{}", output);
}
```

### Response

N/A (This is a library usage example, not an API endpoint)

### Response Example

N/A
```

--------------------------------

### Customize Report Appearance with Config

Source: https://context7.com/zesterer/ariadne/llms.txt

Demonstrates how to use the Config struct to modify diagnostic rendering. It shows both a compact ASCII configuration and a full configuration with custom tab widths, colors, and context lines.

```rust
use ariadne::{Report, ReportKind, Label, Source, Config, CharSet, LabelAttach, IndexType};

fn main() {
    let source = "function test() {\n\treturn x + y;\n}";

    // Compact mode with ASCII characters (for terminals without Unicode support)
    Report::build(ReportKind::Error, 26..27)
        .with_message("Undefined variable")
        .with_config(
            Config::default()
                .with_compact(true)
                .with_char_set(CharSet::Ascii)
        )
        .with_label(Label::new(26..27).with_message("'x' is not defined"))
        .finish()
        .print(Source::from(source))
        .unwrap();

    // Full configuration example
    let config = Config::new()
        .with_cross_gap(true)              // Gap when label lines cross
        .with_label_attach(LabelAttach::Middle)  // Where arrows attach to spans
        .with_compact(false)               // Disable compact mode
        .with_underlines(true)             // Show underlines for inline spans
        .with_multiline_arrows(true)       // Arrows for multi-line spans
        .with_color(true)                  // Enable colored output
        .with_tab_width(4)                 // Tab character width
        .with_index_type(IndexType::Char)  // Use character offsets (vs byte)
        .with_context_lines(2);            // Extra context lines around labels

    Report::build(ReportKind::Warning, 10..15)
        .with_message("Unused variable")
        .with_config(config)
        .with_label(Label::new(10..15).with_message("This variable is never used"))
        .finish()
        .print(Source::from("let unused = 42;\nlet used = 10;\nprintln!(\"{}\", used);"))
        .unwrap();
}
```

--------------------------------

### Create Ariadne Source from Text (Rust)

Source: https://context7.com/zesterer/ariadne/llms.txt

Demonstrates how to create a Source object from string data using `Source::from`. This is essential for Ariadne to parse line information and calculate offsets for error reporting. It shows usage for both single-file and multi-file diagnostics with the `sources()` helper.

```rust
use ariadne::{Report, ReportKind, Label, Source, sources};

fn main() {
    // Single file source
    let code = "let x = 42;\nlet y = x + \"hello\";";
    let src = Source::from(code);

    Report::build(ReportKind::Error, 20..27)
        .with_message("Cannot add integer and string")
        .with_label(Label::new(20..27).with_message("Invalid operation"))
        .finish()
        .print(src)
        .unwrap();

    // Multi-file sources using the sources() helper
    Report::build(ReportKind::Error, ("main.rs", 10..14))
        .with_message("Undefined variable")
        .with_label(
            Label::new(("main.rs", 10..14))
                .with_message("'foo' is not defined")
        )
        .with_label(
            Label::new(("lib.rs", 0..10))
                .with_message("Did you mean 'bar' defined here?")
        )
        .finish()
        .print(sources([
            ("main.rs", "fn main() { foo(); }"),
            ("lib.rs", "pub fn bar() {}"),
        ]))
        .unwrap();
}
```

--------------------------------

### Rust: Building and Printing an Error Report

Source: https://github.com/zesterer/ariadne/blob/main/README.md

This snippet demonstrates how to build a detailed error report using Ariadne. It includes defining incompatible types, highlighting specific code spans with different colors and messages, and adding a note to the report. The report is then printed to stderr.

```Rust
use ariadne::{Color, ColorGenerator, Fmt, Label, Report, ReportKind, Source};

// Generate & choose some colours for each of our elements
let mut colors = ColorGenerator::new();
let a = colors.next();
let b = colors.next();
let out = Color::Blue;

Report::build(ReportKind::Error, ("sample.tao", 12..12))
    .with_message(format!("Incompatible types"))
    .with_label(Label::new(("sample.tao", 32..33))
        .with_message(format!("This is of type {}", "Nat".fg(a)))
        .with_color(a))
    .with_label(Label::new(("sample.tao", 52..55))
        .with_message(format!("This is of type {}", "Str".fg(b)))
        .with_color(b))
    .with_label(Label::new(("sample.tao", 11..58))
        .with_message(format!("The values are outputs of this {} expression", "match".fg(out)))
        .with_color(out))
    .with_note(format!("Outputs of {} expressions must coerce to the same type", "match".fg(out)))
    .finish()
    .eprint(("sample.tao", Source::from(include_str!("sample.tao"))))
    .unwrap();
```

--------------------------------

### Outputting Diagnostic Reports in Rust

Source: https://context7.com/zesterer/ariadne/llms.txt

Demonstrates how to output diagnostic reports to stdout, stderr, and custom buffers using the Ariadne library. It shows the usage of the print, eprint, and write methods to handle different diagnostic reporting needs.

```rust
use ariadne::{Report, ReportKind, Label, Source};
use std::io::Write;

fn main() {
    let source = Source::from("let x = 10;");

    // Print to stdout
    Report::build(ReportKind::Advice, 4..5)
        .with_message("Consider using a more descriptive name")
        .with_label(Label::new(4..5).with_message("Rename this variable"))
        .finish()
        .print(source.clone())
        .unwrap();

    // Print to stderr (preferred for diagnostics)
    Report::build(ReportKind::Error, 4..5)
        .with_message("Undefined variable")
        .with_label(Label::new(4..5).with_message("'x' not found"))
        .finish()
        .eprint(source.clone())
        .unwrap();

    // Write to a custom destination (file, buffer, etc.)
    let mut buffer = Vec::new();
    Report::build(ReportKind::Warning, 8..10)
        .with_message("Magic number detected")
        .with_label(Label::new(8..10).with_message("Consider using a named constant"))
        .finish()
        .write(source, &mut buffer)
        .unwrap();

    let output = String::from_utf8(buffer).unwrap();
    println!("Captured output:\n{}", output);
}
```

--------------------------------

### Add Notes and Help Messages to Reports

Source: https://context7.com/zesterer/ariadne/llms.txt

Shows how to append explanatory notes and actionable help messages to diagnostic reports. These messages support formatting and multi-line text to provide better context for errors.

```rust
use ariadne::{Report, ReportKind, Label, Source, Color, Fmt};

fn main() {
    let source = "let x: String = 42;";

    Report::build(ReportKind::Error, 16..18)
        .with_message("Mismatched types")
        .with_label(
            Label::new(16..18)
                .with_message("Expected String, found integer")
                .with_color(Color::Red)
        )
        .with_label(
            Label::new(7..13)
                .with_message("Expected due to this type annotation")
                .with_color(Color::Blue)
        )
        .with_note("Strings and integers are distinct types in Rust")
        .with_note(format!(
            "{} cannot be implicitly converted to {}",
            "i32".fg(Color::Yellow),
            "String".fg(Color::Cyan)
        ))
        .with_help("Consider using .to_string() to convert the integer")
        .with_help("Or change the type annotation to i32")
        .with_help("You can convert like this:\n  let x: String = 42.to_string();")
        .finish()
        .eprint(Source::from(source))
        .unwrap();
}
```

--------------------------------

### Report::build

Source: https://github.com/zesterer/ariadne/blob/main/README.md

The primary entry point for creating a diagnostic report. This method initiates the builder pattern to construct a report with messages, labels, and notes.

```APIDOC
## Report::build

### Description
Creates a new ReportBuilder for a specific file and span. This is the starting point for defining a diagnostic.

### Method
Static Method

### Parameters
#### Arguments
- **kind** (ReportKind) - Required - The severity of the report (Error, Warning, etc.)
- **span** (tuple) - Required - A tuple containing the file identifier and the range of the span (e.g., ("file.rs", 12..15))

### Request Example
Report::build(ReportKind::Error, ("sample.tao", 12..12))

### Response
#### Success Response
- **ReportBuilder** (Object) - Returns a builder instance to chain .with_message(), .with_label(), and .with_note().
```

--------------------------------

### Generate Distinct Colors with ColorGenerator (Rust)

Source: https://context7.com/zesterer/ariadne/llms.txt

Illustrates the use of `ColorGenerator` to produce a sequence of visually distinct colors for highlighting elements in diagnostics. The generator is deterministic and configurable for brightness, ensuring good visibility. It also shows how to create a custom generator with a specific initial state and brightness.

```rust
use ariadne::{Report, ReportKind, Label, Source, Color, ColorGenerator, Fmt};

fn main() {
    let mut colors = ColorGenerator::new();

    // Generate colors for different elements
    let type_a = colors.next();
    let type_b = colors.next();
    let operator = colors.next();

    let source = "let result = calculate(x, y) + transform(z);";

    Report::build(ReportKind::Error, 13..28)
        .with_message(format!(
            "Cannot combine {} and {}",
            "Number".fg(type_a),
            "String".fg(type_b)
        ))
        .with_label(
            Label::new(13..28)
                .with_message(format!("Returns {}", "Number".fg(type_a)))
                .with_color(type_a)
        )
        .with_label(
            Label::new(31..43)
                .with_message(format!("Returns {}", "String".fg(type_b)))
                .with_color(type_b)
        )
        .with_label(
            Label::new(29..30)
                .with_message("Addition operator requires matching types")
                .with_color(operator)
        )
        .finish()
        .print(Source::from(source))
        .unwrap();

    // Custom color generator with different initial state and brightness
    let custom_gen = ColorGenerator::from_state([10000, 20000, 30000], 0.7);
}
```

--------------------------------

### Report::finish

Source: https://github.com/zesterer/ariadne/blob/main/README.md

Finalizes the builder configuration and produces a Report object ready for printing.

```APIDOC
## Report::finish

### Description
Consumes the ReportBuilder and returns a finished Report instance.

### Method
Instance Method

### Parameters
None

### Response
#### Success Response
- **Report** (Object) - The final diagnostic report object that can be passed to print or eprint methods.
```

--------------------------------

### TOML: Equivalent Concolor Configuration for Ariadne

Source: https://github.com/zesterer/ariadne/blob/main/README.md

This TOML snippet demonstrates an alternative and more explicit way to configure color support for Ariadne by directly specifying the 'concolor' dependency with its 'auto' feature. This achieves the same result as using Ariadne's 'auto-color' feature.

```TOML
[dependencies]
ariadne = { version = "...", features = ["concolor"] }
concolor = { version = "...", features = ["auto"] }
```

--------------------------------

### Fmt Trait - Inline Text Coloring

Source: https://context7.com/zesterer/ariadne/llms.txt

Explains the use of the Fmt trait for applying foreground and background colors to diagnostic messages.

```APIDOC
## Fmt Trait - Inline Text Coloring

### Description
The Fmt trait provides a simple interface to apply ANSI colors to strings within diagnostic messages, improving readability and highlighting specific types or values.

### Method
N/A (Rust Library API)

### Parameters
#### Request Body
- **fg(Color)** (Method) - Required - Sets the foreground color of the string.
- **bg(Color)** (Method) - Optional - Sets the background color of the string.

### Request Example
```rust
let int_type = "i32".fg(Color::Blue);
let str_type = "str".fg(Color::Red);
format!("Cannot pass {} where {} is expected", str_type, int_type);
```
```

--------------------------------

### Ariadne: Multi-line Labels and Complex Spans in Rust

Source: https://context7.com/zesterer/ariadne/llms.txt

Demonstrates how Ariadne can create multi-line labels and complex spans for error reporting. This is useful for highlighting entire code blocks or nested structures that span multiple lines. It shows how to define outer and inner labels with distinct colors and messages.

```rust
use ariadne::{Report, ReportKind, Label, Source, Color, ColorGenerator, Fmt};

fn main() {
    let mut colors = ColorGenerator::new();
    let outer = colors.next();
    let inner = colors.next();
    let value = colors.next();

    let source = r###"def foo = {
    match x {
        true => 1,
        false => "error"
    }
}
foo(true)"###;

    Report::build(ReportKind::Error, ("sample.tao", 32..33))
        .with_message("Incompatible types in match expression")
        // Multi-line label spanning the entire match expression
        .with_label(
            Label::new(("sample.tao", 16..69))
                .with_message(format!("The {} expression has mismatched arms", "match".fg(outer)))
                .with_color(outer)
        )
        // Inner labels for specific values
        .with_label(
            Label::new(("sample.tao", 48..49))
                .with_message(format!("This is of type {}", "Nat".fg(value)))
                .with_color(value)
        )
        .with_label(
            Label::new(("sample.tao", 67..74))
                .with_message(format!("This is of type {}", "Str".fg(inner)))
                .with_color(inner)
        )
        // Outer label for the entire definition
        .with_label(
            Label::new(("sample.tao", 0..76))
                .with_message("In this definition")
                .with_color(Color::Fixed(240))
        )
        .with_note(format!(
            "All arms of a {} expression must return the same type",
            "match".fg(outer)
        ))
        .finish()
        .print(("sample.tao", Source::from(source)))
        .unwrap();
}

```

--------------------------------

### Notes and Help Messages in Reports

Source: https://context7.com/zesterer/ariadne/llms.txt

Illustrates how to add explanatory notes and actionable help messages to Ariadne reports, including support for multi-line content and automatic numbering.

```APIDOC
## Notes and Help Messages

Reports support notes (explanatory text) and help messages (actionable suggestions) that appear after the source code display. Multiple notes and help messages can be added, and they support multi-line content. When multiple notes or helps exist, they are automatically numbered.

### Example Usage

```rust
use ariadne::{Report, ReportKind, Label, Source, Color, Fmt};

fn main() {
    let source = "let x: String = 42;";

    Report::build(ReportKind::Error, 16..18)
        .with_message("Mismatched types")
        .with_label(
            Label::new(16..18)
                .with_message("Expected String, found integer")
                .with_color(Color::Red)
        )
        .with_label(
            Label::new(7..13)
                .with_message("Expected due to this type annotation")
                .with_color(Color::Blue)
        )
        // Add explanatory notes
        .with_note("Strings and integers are distinct types in Rust")
        .with_note(format!(
            "{} cannot be implicitly converted to {}",
            "i32".fg(Color::Yellow),
            "String".fg(Color::Cyan)
        ))
        // Add actionable help messages
        .with_help("Consider using .to_string() to convert the integer")
        .with_help("Or change the type annotation to i32")
        // Multi-line help is also supported
        .with_help("You can convert like this:\n  let x: String = 42.to_string();")
        .finish()
        .eprint(Source::from(source))
        .unwrap();
}
```
```

--------------------------------

### Multi-line Labels and Complex Spans

Source: https://context7.com/zesterer/ariadne/llms.txt

Demonstrates how to construct complex diagnostic reports with multi-line labels and nested spans to highlight code structures.

```APIDOC
## Multi-line Labels and Complex Spans

### Description
This functionality allows developers to create diagnostic reports that span multiple lines, using connecting lines and arrows to visualize nested code structures or blocks.

### Method
N/A (Rust Library API)

### Parameters
#### Request Body
- **Report::build** (Function) - Required - Initializes the report with kind and span.
- **Label::new** (Function) - Required - Defines a region of code to highlight.
- **with_color** (Method) - Optional - Assigns a specific color to the label.

### Request Example
```rust
Report::build(ReportKind::Error, ("sample.tao", 32..33))
    .with_label(Label::new(("sample.tao", 16..69)).with_message("Match expression"))
    .finish()
    .print(("sample.tao", Source::from(source)));
```
```

--------------------------------

### Define Diagnostic Severity with ReportKind

Source: https://context7.com/zesterer/ariadne/llms.txt

Illustrates the use of ReportKind to set diagnostic severity levels. It covers standard types like Error, Warning, and Advice, as well as creating a Custom report kind with a specific name and color.

```rust
use ariadne::{Report, ReportKind, Label, Source, Color};

fn main() {
    let source = "let x = 10 / 0;";

    // Error - critical problem (red)
    Report::build(ReportKind::Error, 13..14)
        .with_message("Division by zero")
        .with_label(Label::new(13..14).with_message("Zero divisor"))
        .finish()
        .eprint(Source::from(source))
        .unwrap();

    // Warning - potential problem (yellow)
    Report::build(ReportKind::Warning, 4..5)
        .with_message("Unused variable")
        .with_label(Label::new(4..5).with_message("'x' is never read"))
        .finish()
        .eprint(Source::from(source))
        .unwrap();

    // Advice - suggestion (purple-ish)
    Report::build(ReportKind::Advice, 8..14)
        .with_message("Consider using checked division")
        .with_label(Label::new(8..14).with_message("Use checked_div() instead"))
        .finish()
        .eprint(Source::from(source))
        .unwrap();

    // Custom report kind with custom name and color
    Report::build(ReportKind::Custom("Lint", Color::Cyan), 0..15)
        .with_message("Style violation detected")
        .with_label(Label::new(0..15).with_message("Consider reformatting"))
        .finish()
        .eprint(Source::from(source))
        .unwrap();
}
```

--------------------------------

### Ariadne: Fmt Trait for Inline Text Coloring in Rust

Source: https://context7.com/zesterer/ariadne/llms.txt

Illustrates the use of the `Fmt` trait's `fg()` and `bg()` methods for applying foreground and background colors to text within error messages. This enhances readability by highlighting specific terms, keywords, or types. Colors respect terminal capabilities when the `concolor` feature is enabled.

```rust
use ariadne::{Report, ReportKind, Label, Source, Color, Fmt};

fn main() {
    let source = "let result = add(1, \"two\");";

    // Using Fmt trait for inline coloring in messages
    let int_type = "i32".fg(Color::Blue);
    let str_type = "str".fg(Color::Red);

    Report::build(ReportKind::Error, 20..25)
        .with_message(format!(
            "Cannot pass {} where {} is expected",
            str_type,
            int_type
        ))
        .with_label(
            Label::new(17..18)
                .with_message(format!("This argument is {}", int_type))
                .with_color(Color::Blue)
        )
        .with_label(
            Label::new(20..25)
                .with_message(format!("This argument is {}", str_type))
                .with_color(Color::Red)
        )
        .with_note(format!(
            "The {} function signature is: fn add(a: {}, b: {}) -> {}",
            "add".fg(Color::Yellow),
            int_type,
            int_type,
            int_type
        ))
        .with_help(format!(
            "Try converting the {} to {} using {}.parse::<{}>()",
            str_type,
            int_type,
            "\"two\"".fg(Color::Green),
            "i32".fg(Color::Blue)
        ))
        .finish()
        .eprint(Source::from(source))
        .unwrap();
}

```

--------------------------------

### Report::eprint

Source: https://github.com/zesterer/ariadne/blob/main/README.md

Writes the generated report to the standard error stream.

```APIDOC
## Report::eprint

### Description
Prints the diagnostic report to stderr using a provided file cache.

### Method
Instance Method

### Parameters
#### Arguments
- **cache** (Source) - Required - The source file cache used to resolve spans into actual text content.

### Request Example
report.eprint(("sample.tao", Source::from(include_str!("sample.tao"))))
```
Tokens:
Raw