use codespan_reporting::diagnostic::{Diagnostic, Label, LabelStyle, Severity};use codespan_reporting::files::SimpleFiles;use codespan_reporting::term;use codespan_reporting::term::termcolor::{ColorChoice, StandardStream};use std::ops::Range;use std::path::PathBuf; /// A warning about a blocking call detected in an async context.#[derive(Debug, Clone)]pub struct Warning {    /// Path to the source file.    pub path: PathBuf,    /// Byte offset range of the call expression within the source file.    pub span: Range<usize>,    /// The resolved call path that matched the blocklist.    pub call_path: String,    /// Category from the blocklist entry (e.g., "filesystem").    pub category: String,    /// Help text from the blocklist entry.    pub help: String,    /// Description of the async context (e.g., "async fn `load_file`").    pub context: String,} /// Render all warnings for a single file using codespan-reporting.pub fn emit_file_warnings(warnings: &[Warning], source: &str, path: &str, format: &str) {    if warnings.is_empty() {        return;    }    match format {        "json" => {            for warning in warnings {                emit_json(warning);            }        }        _ => emit_human_batch(warnings, source, path),    }} fn emit_human_batch(warnings: &[Warning], source: &str, path: &str) {    let mut files = SimpleFiles::new();    let file_id = files.add(path, source);     let writer = StandardStream::stderr(ColorChoice::Auto);    let config = term::Config::default();     for warning in warnings {        let diagnostic = Diagnostic::new(Severity::Warning)            .with_code("blocking-in-async")            .with_message("blocking call in async context")            .with_labels(vec![Label::new(                LabelStyle::Primary,                file_id,                warning.span.clone(),            )            .with_message(format!(                "`{}` is a blocking {} operation",                warning.call_path, warning.category            ))])            .with_notes(vec![                format!("help: {}", warning.help),                format!("context: {}", warning.context),            ]);         term::emit_to_write_style(&mut writer.lock(), &config, &files, &diagnostic)            .expect("failed to write diagnostic");    }} fn emit_json(warning: &Warning) {    println!(        r#"{{"level":"warning","code":"blocking-in-async","path":"{}","byte_start":{},"byte_end":{},"call":"{}","category":"{}","help":"{}","context":"{}"}}"#,        warning.path.display(),        warning.span.start,        warning.span.end,        warning.call_path,        warning.category,        warning.help,        warning.context,    );}