_diffctx/edges/semantic/
ocaml.rs

1use std::path::{Path, PathBuf};
2
3use once_cell::sync::Lazy;
4use regex::Regex;
5use rustc_hash::{FxHashMap, FxHashSet};
6
7use crate::config::weights::EDGE_WEIGHTS;
8use crate::types::Fragment;
9
10use super::super::EdgeDict;
11use super::super::base::{self, EdgeBuilder, add_edge, add_edges_from_ids, discover_files_by_refs};
12
13fn is_ocaml_file(path: &Path) -> bool {
14    let ext = base::file_ext(path);
15    ext == ".ml" || ext == ".mli"
16}
17
18static OPEN_RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"(?m)^\s*open\s+([A-Z]\w*)").unwrap());
19static INCLUDE_RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"(?m)^\s*include\s+([A-Z]\w*)").unwrap());
20static MODULE_DEF_RE: Lazy<Regex> =
21    Lazy::new(|| Regex::new(r"(?m)^\s*module\s+([A-Z]\w*)").unwrap());
22static LET_RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"(?m)^\s*let\s+(\w+)").unwrap());
23static VAL_RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"(?m)^\s*val\s+(\w+)").unwrap());
24static TYPE_DEF_RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"(?m)^\s*type\s+(\w+)").unwrap());
25static MODULE_REF_RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"\b([A-Z]\w*)\.\w+").unwrap());
26
27fn extract_opens(content: &str) -> FxHashSet<String> {
28    let mut refs = FxHashSet::default();
29    refs.extend(OPEN_RE.captures_iter(content).map(|c| c[1].to_string()));
30    refs.extend(INCLUDE_RE.captures_iter(content).map(|c| c[1].to_string()));
31    refs
32}
33
34fn extract_defs(content: &str) -> FxHashSet<String> {
35    let mut defs = FxHashSet::default();
36    defs.extend(
37        MODULE_DEF_RE
38            .captures_iter(content)
39            .map(|c| c[1].to_string()),
40    );
41    defs.extend(LET_RE.captures_iter(content).map(|c| c[1].to_string()));
42    defs.extend(VAL_RE.captures_iter(content).map(|c| c[1].to_string()));
43    defs.extend(TYPE_DEF_RE.captures_iter(content).map(|c| c[1].to_string()));
44    defs
45}
46
47fn extract_module_refs(content: &str) -> FxHashSet<String> {
48    MODULE_REF_RE
49        .captures_iter(content)
50        .map(|c| c[1].to_string())
51        .collect()
52}
53
54pub struct OCamlEdgeBuilder;
55
56impl EdgeBuilder for OCamlEdgeBuilder {
57    fn build(&self, fragments: &[Fragment], repo_root: Option<&Path>) -> EdgeDict {
58        let frags: Vec<&Fragment> = fragments
59            .iter()
60            .filter(|f| is_ocaml_file(Path::new(f.path())))
61            .collect();
62        if frags.is_empty() {
63            return FxHashMap::default();
64        }
65
66        let open_w = EDGE_WEIGHTS["ocaml_open"].forward;
67        let _type_w = EDGE_WEIGHTS["ocaml_type"].forward;
68        let fn_w = EDGE_WEIGHTS["ocaml_fn"].forward;
69        let mod_w = EDGE_WEIGHTS["ocaml_module_ref"].forward;
70        let reverse_factor = EDGE_WEIGHTS["ocaml_open"].reverse_factor;
71
72        let idx = base::FragmentIndex::new(fragments, repo_root);
73        let mut name_to_defs: FxHashMap<String, Vec<_>> = FxHashMap::default();
74        for f in &frags {
75            for name in extract_defs(&f.content) {
76                name_to_defs
77                    .entry(name.to_lowercase())
78                    .or_default()
79                    .push(f.id.clone());
80            }
81        }
82
83        let mut edges: EdgeDict = FxHashMap::default();
84
85        for f in &frags {
86            let self_defs = extract_defs(&f.content);
87            for open_name in extract_opens(&f.content) {
88                base::link_by_name(&f.id, &open_name, &idx, &mut edges, open_w, reverse_factor);
89                if let Some(targets) = name_to_defs.get(&open_name.to_lowercase()) {
90                    add_edges_from_ids(&mut edges, &f.id, targets, open_w, reverse_factor);
91                }
92            }
93            for mref in extract_module_refs(&f.content) {
94                if self_defs.contains(&mref) {
95                    continue;
96                }
97                if let Some(targets) = name_to_defs.get(&mref.to_lowercase()) {
98                    for t in targets {
99                        if t != &f.id {
100                            add_edge(&mut edges, &f.id, t, mod_w, reverse_factor);
101                        }
102                    }
103                }
104            }
105            for id in &f.identifiers {
106                if self_defs.contains(id) {
107                    continue;
108                }
109                if let Some(targets) = name_to_defs.get(&id.to_lowercase()) {
110                    for t in targets {
111                        if t != &f.id {
112                            add_edge(&mut edges, &f.id, t, fn_w, reverse_factor);
113                        }
114                    }
115                }
116            }
117        }
118        edges
119    }
120
121    fn discover_related_files(
122        &self,
123        changed: &[PathBuf],
124        candidates: &[PathBuf],
125        repo_root: Option<&Path>,
126        file_cache: Option<&FxHashMap<PathBuf, String>>,
127    ) -> Vec<PathBuf> {
128        let ml_changed: Vec<&PathBuf> = changed.iter().filter(|f| is_ocaml_file(f)).collect();
129        if ml_changed.is_empty() {
130            return vec![];
131        }
132        let mut refs = FxHashSet::default();
133        for f in &ml_changed {
134            if let Some(content) = base::read_file_cached(f, file_cache) {
135                refs.extend(extract_opens(&content));
136                refs.extend(extract_module_refs(&content));
137            }
138        }
139        discover_files_by_refs(&refs, changed, candidates, repo_root)
140    }
141}
_diffctx/edges/semantic/ocaml.rs

_diffctx/edges/semantic/
ocaml.rs
