mirage-analyzer 1.5.1

Path-Aware Code Intelligence Engine for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

use crate::cli::{resolve_db_path, Cli, OutputFormat, SuggestArgs};
use crate::output;
use anyhow::Result;

pub fn suggest(args: &SuggestArgs, cli: &Cli) -> Result<()> {
    use crate::analysis::suggest;
    use crate::storage::MirageDb;

    let db_path = resolve_db_path(cli.db.clone())?;
    let db = match MirageDb::open(&db_path) {
        Ok(db) => db,
        Err(e) => {
            if matches!(cli.output, OutputFormat::Json | OutputFormat::Pretty) {
                let error = output::JsonError::database_not_found(&db_path);
                let wrapper = output::JsonResponse::new(error);
                println!("{}", wrapper.to_json());
                std::process::exit(output::EXIT_DATABASE);
            } else {
                output::error(&format!("Failed to open database: {}", e));
                std::process::exit(output::EXIT_DATABASE);
            }
        }
    };

    let function_id = match crate::cfg::resolve_function_name_with_file(
        &db,
        &args.symbol,
        args.file.as_deref(),
    ) {
        Ok(id) => id,
        Err(_) => {
            if matches!(cli.output, OutputFormat::Json | OutputFormat::Pretty) {
                let error = output::JsonError::function_not_found(&args.symbol);
                let wrapper = output::JsonResponse::new(error);
                println!("{}", wrapper.to_json());
                std::process::exit(output::EXIT_DATABASE);
            } else {
                output::error(&format!("Symbol '{}' not found", args.symbol));
                std::process::exit(output::EXIT_DATABASE);
            }
        }
    };

    let report =
        suggest::compute_suggestions(&db, function_id, &args.symbol, args.file.as_deref())?;

    match cli.output {
        OutputFormat::Human => {
            println!("Suggestions for: {}", report.symbol);
            if let Some(ref fp) = report.file_path {
                println!("  File: {}", fp);
            }
            println!();
            for s in &report.suggestions {
                println!(
                    "  [{}] {} ({})",
                    s.severity.to_uppercase(),
                    s.message,
                    s.kind
                );
                if let Some(ref detail) = s.detail {
                    println!("    {}", detail);
                }
            }
        }
        OutputFormat::Json => {
            let response = output::JsonResponse::new(&report);
            println!("{}", response.to_json());
        }
        OutputFormat::Pretty => {
            let response = output::JsonResponse::new(&report);
            println!("{}", response.to_pretty_json());
        }
    }

    Ok(())
}