repopilot 0.18.0

Local-first CLI for reviewing Git changes, security boundaries, and blast radius before merge.
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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

//! Rust import resolution (`crate::`, `self::`, `super::`, `mod::`).

use super::probe;
use std::collections::HashSet;
use std::path::{Path, PathBuf};

pub(super) fn resolve_rust(
    raw: &str,
    from_file: &Path,
    root: &Path,
    known_files: &HashSet<PathBuf>,
) -> Option<PathBuf> {
    if let Some(name) = raw.strip_prefix("mod::") {
        let dir = rust_current_module_dir(from_file, root);
        return probe(
            &[
                dir.join(format!("{name}.rs")),
                dir.join(name).join("mod.rs"),
            ],
            known_files,
        );
    }

    // `#[path = "..."] mod x;` and `include!("...")` both resolve relative to
    // the directory of the file that declares them.
    if let Some(rel) = raw.strip_prefix("relfile::") {
        let base = from_file
            .parent()
            .map(Path::to_path_buf)
            .unwrap_or_else(|| root.to_path_buf());
        return probe(&[base.join(rel)], known_files);
    }

    if let Some(rest) = raw.strip_prefix("crate::") {
        let src_root = root.join("src");
        return resolve_rust_module_path(&src_root, rest, known_files);
    }

    if let Some(rest) = raw.strip_prefix("self::") {
        let module_dir = rust_current_module_dir(from_file, root);
        return resolve_rust_module_path(&module_dir, rest, known_files);
    }

    if raw.starts_with("super::") {
        let mut remaining = raw;
        let mut base = rust_current_module_dir(from_file, root);
        while let Some(rest) = remaining.strip_prefix("super::") {
            base = base.parent().unwrap_or(root).to_path_buf();
            remaining = rest;
        }
        return resolve_rust_module_path(&base, remaining, known_files);
    }

    None
}

fn resolve_rust_module_path(
    base_dir: &Path,
    module_path: &str,
    known_files: &HashSet<PathBuf>,
) -> Option<PathBuf> {
    let segments = module_path
        .split("::")
        .filter(|segment| !segment.is_empty() && *segment != "self")
        .collect::<Vec<_>>();

    for end in (1..=segments.len()).rev() {
        let base = segments[..end]
            .iter()
            .fold(base_dir.to_path_buf(), |path, segment| path.join(segment));
        if let Some(path) = probe_rust_module_file(&base, known_files) {
            return Some(path);
        }
    }

    None
}

fn probe_rust_module_file(base: &Path, known_files: &HashSet<PathBuf>) -> Option<PathBuf> {
    probe(
        &[base.with_extension("rs"), base.join("mod.rs")],
        known_files,
    )
}

fn rust_current_module_dir(from_file: &Path, root: &Path) -> PathBuf {
    let src_root = root.join("src");
    let file_name = from_file.file_name().and_then(|name| name.to_str());

    match file_name {
        Some("lib.rs" | "main.rs" | "mod.rs") => from_file
            .parent()
            .map(Path::to_path_buf)
            .unwrap_or(src_root),
        Some(_) => from_file.with_extension(""),
        None => src_root,
    }
}