use tree_sitter::Node;
use super::{
DocCommentSpec, SymbolSink, collect_symbols, find_first_named_child, push_named_symbol,
walk_children,
};
pub(super) const DOC_SPEC: DocCommentSpec = DocCommentSpec {
comment_node_types: &["line_comment", "block_comment"],
doc_prefixes: Some(&["///", "//!", "/**", "/*!"]),
custom_doc_check: None,
};
use crate::domain::{SymbolKind, SymbolRecord};
pub fn extract_symbols(node: &Node, source: &str) -> Vec<SymbolRecord> {
collect_symbols(node, source, walk_node)
}
fn walk_node(
node: &Node,
source: &str,
depth: u32,
sort_order: &mut u32,
symbols: &mut Vec<SymbolRecord>,
) {
let kind = match node.kind() {
"function_item" => Some(SymbolKind::Function),
"struct_item" => Some(SymbolKind::Struct),
"enum_item" => Some(SymbolKind::Enum),
"trait_item" => Some(SymbolKind::Trait),
"impl_item" => Some(SymbolKind::Impl),
"const_item" => Some(SymbolKind::Constant),
"static_item" => Some(SymbolKind::Variable),
"mod_item" => Some(SymbolKind::Module),
"type_item" => Some(SymbolKind::Type),
_ => None,
};
{
let mut sink = SymbolSink::new(source, sort_order, symbols, &DOC_SPEC);
push_named_symbol(
node,
depth,
kind,
|node, source, _| find_name(node, source),
&mut sink,
);
}
walk_children(node, source, depth, sort_order, symbols, kind, walk_node);
}
fn find_name(node: &Node, source: &str) -> Option<String> {
if node.kind() == "impl_item" {
return extract_impl_name(node, source);
}
find_first_named_child(node, source, &["name", "identifier", "type_identifier"])
}
fn extract_impl_name(node: &Node, source: &str) -> Option<String> {
let mut cursor = node.walk();
let children: Vec<_> = node.children(&mut cursor).collect();
let mut trait_name = None;
let mut type_name = None;
let mut found_for = false;
for child in &children {
match child.kind() {
"type_identifier" | "scoped_type_identifier" | "generic_type" => {
let text = child.utf8_text(source.as_bytes()).unwrap_or("").to_string();
if found_for {
type_name = Some(text);
} else if trait_name.is_none() {
trait_name = Some(text);
} else {
type_name = Some(text);
}
}
"for" => {
found_for = true;
}
_ => {}
}
}
if found_for && let (Some(tr), Some(ty)) = (&trait_name, &type_name) {
return Some(format!("impl {tr} for {ty}"));
}
trait_name.map(|n| format!("impl {n}"))
}