Something went wrong. Try again.
Identities for entities did.bot
agent llm did
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169//! The item inventory, read out of rustdoc's JSON output.//!//! rustdoc knows each item's kind, its visibility, the module path it is//! reached by and the source span it occupies. LSIF knows none of that well,//! which is why the index is built from both.
use crate::layout::Layout;use anyhow::{Context, Result};use serde_json::Value;use std::collections::HashSet;use std::path::PathBuf;
pub struct Item { pub krate: String, pub module_path: String, pub name: String, pub kind: String, pub visibility: String, pub file: String, pub line_start: u32, pub line_end: u32, pub target_kind: String, /// Every module between the crate root and this item is `pub`, so the /// item is part of the crate's published API rather than merely spelled /// `pub` inside a private module. pub exported: bool,}
/// Reads every `*.json` in each rustdoc JSON output directory.////// More than one directory, because rustdoc names its output after the crate/// and a package's lib and its bin often share a name: documenting the two/// into one directory loses whichever ran first.pub fn load(dirs: &[PathBuf], layout: &Layout) -> Result<Vec<Item>> { let mut items = Vec::new(); let mut entries: Vec<_> = Vec::new(); for dir in dirs { entries.extend( std::fs::read_dir(dir) .with_context(|| format!("reading {}", dir.display()))? .filter_map(|e| e.ok()) .map(|e| e.path()) .filter(|p| p.extension().is_some_and(|e| e == "json")), ); } entries.sort(); for path in entries { let text = std::fs::read_to_string(&path) .with_context(|| format!("reading {}", path.display()))?; let doc: Value = serde_json::from_str(&text).with_context(|| format!("parsing {}", path.display()))?; walk_crate(&doc, layout, &mut items); } items.sort_by(|a, b| (&a.file, a.line_start, &a.name).cmp(&(&b.file, b.line_start, &b.name))); items.dedup_by(|a, b| (&a.file, a.line_start, &a.name) == (&b.file, b.line_start, &b.name)); Ok(items)}
fn walk_crate(doc: &Value, layout: &Layout, out: &mut Vec<Item>) { let index = match doc["index"].as_object() { Some(i) => i, None => return, }; let root = doc["root"].to_string().trim_matches('"').to_string(); let mut seen = HashSet::new(); let mut stack = vec![(root, Vec::<String>::new(), true)]; while let Some((id, prefix, public_chain)) = stack.pop() { if !seen.insert(id.clone()) { continue; } let item = match index.get(&id) { Some(i) => i, None => continue, }; let kind = kind_of(item); // A `use` carries no name of its own; the name it binds sits in the // re-export body, and its span is exactly that name's spelling. let name = item["name"] .as_str() .or_else(|| item["inner"]["use"]["name"].as_str()) .unwrap_or_default() .to_string(); let visibility = visibility_of(item); let public = matches!(visibility.as_str(), "public" | "default");
if let Some(span) = item["span"].as_object() { let file = span["filename"].as_str().unwrap_or_default(); if file.starts_with("crates/") && kind != "impl" && !name.is_empty() { if let Some((krate, target_kind)) = layout.locate(file) { out.push(Item { krate: krate.to_string(), module_path: prefix.join("::"), name: name.clone(), kind: kind.clone(), visibility: visibility.clone(), file: file.to_string(), line_start: span["begin"][0].as_u64().unwrap_or(0) as u32, line_end: span["end"][0].as_u64().unwrap_or(0) as u32, target_kind: target_kind.to_string(), exported: public_chain && visibility == "public", }); } } }
// An impl block is already filed under the type it is written for, so // it adds nothing to the path; everything else that can hold items // does. A `use` binds a name without opening a scope. let child_prefix = if kind == "impl" || kind == "use" || name.is_empty() { prefix } else { let mut p = prefix; p.push(name); p }; let child_chain = public_chain && public; for child in children(item) { stack.push((child, child_prefix.clone(), child_chain)); } }}
fn kind_of(item: &Value) -> String { item["inner"] .as_object() .and_then(|o| o.keys().next()) .cloned() .unwrap_or_else(|| "unknown".to_string())}
fn visibility_of(item: &Value) -> String { match &item["visibility"] { Value::String(s) => s.clone(), Value::Object(_) => "restricted".to_string(), _ => "default".to_string(), }}
/// Every child id an item can carry, whatever shape rustdoc gives it.fn children(item: &Value) -> Vec<String> { let mut out = Vec::new(); let Some(inner) = item["inner"].as_object() else { return out; }; for body in inner.values() { for key in ["items", "impls", "variants", "fields"] { push_ids(&body[key], &mut out); } // Struct and enum-variant payloads nest their field list one level // further, under the shape of the thing. if let Some(shape) = body["kind"].as_object() { for form in shape.values() { push_ids(&form["fields"], &mut out); } } } out}
fn push_ids(value: &Value, out: &mut Vec<String>) { if let Some(list) = value.as_array() { for id in list { if let Some(n) = id.as_u64() { out.push(n.to_string()); } } }}