use super::RawSymbol;
use super::classify::classify_node;
use super::names::extract_name;
use crate::types::{Language, SymbolType};
pub(super) fn extract_scheme_define(
node: &tree_sitter::Node<'_>,
source: &[u8],
) -> Option<RawSymbol> {
let mut cursor = node.walk();
let children: Vec<_> = node.children(&mut cursor).collect();
let first_sym = children.iter().find(|c| c.kind() == "symbol")?;
let keyword = first_sym.utf8_text(source).ok()?;
let sym_type = match keyword {
"define" | "define-syntax" => SymbolType::Function,
_ => return None,
};
let after_keyword: Vec<_> = children
.iter()
.skip_while(|c| c.start_byte() <= first_sym.start_byte())
.filter(|c| c.kind() != "(" && c.kind() != ")")
.collect();
let name = if let Some(next) = after_keyword.first() {
if next.kind() == "list" {
let mut inner_cursor = next.walk();
next.children(&mut inner_cursor)
.find(|c| c.kind() == "symbol")
.and_then(|c| c.utf8_text(source).ok().map(|s| s.to_string()))
} else if next.kind() == "symbol" {
next.utf8_text(source).ok().map(|s| s.to_string())
} else {
None
}
} else {
None
};
Some(RawSymbol::at(node, name, sym_type))
}
pub(super) fn extract_racket_define(
node: &tree_sitter::Node<'_>,
source: &[u8],
) -> Option<RawSymbol> {
let mut cursor = node.walk();
let children: Vec<_> = node.children(&mut cursor).collect();
let first_sym = children.iter().find(|c| c.kind() == "symbol")?;
let keyword = first_sym.utf8_text(source).ok()?;
let sym_type = match keyword {
"define" | "define-syntax" => SymbolType::Function,
"module" | "module*" | "module+" => SymbolType::Module,
"struct" => SymbolType::Struct,
_ => return None,
};
let after_keyword: Vec<_> = children
.iter()
.skip_while(|c| c.start_byte() <= first_sym.start_byte())
.filter(|c| c.kind() != "(" && c.kind() != ")")
.collect();
let name = if let Some(next) = after_keyword.first() {
if next.kind() == "list" {
let mut inner_cursor = next.walk();
next.children(&mut inner_cursor)
.find(|c| c.kind() == "symbol")
.and_then(|c| c.utf8_text(source).ok().map(|s| s.to_string()))
} else if next.kind() == "symbol" {
next.utf8_text(source).ok().map(|s| s.to_string())
} else {
None
}
} else {
None
};
Some(RawSymbol::at(node, name, sym_type))
}
pub(super) const CLOJURE_DEFINE_KINDS: &[(&[&str], SymbolType)] = &[
(&["defn", "defmacro", "defn-"], SymbolType::Function),
(&["ns"], SymbolType::Module),
(&["def", "defonce"], SymbolType::Variable),
];
pub(super) const COMMONLISP_DEFINE_KINDS: &[(&[&str], SymbolType)] = &[
(&["defclass"], SymbolType::Class),
(
&["defvar", "defparameter", "defconstant"],
SymbolType::Variable,
),
(&["defpackage"], SymbolType::Module),
(
&["defmacro", "defgeneric", "defmethod"],
SymbolType::Function,
),
];
pub(super) fn extract_lisp_define(
node: &tree_sitter::Node<'_>,
source: &[u8],
keyword_types: &[(&[&str], SymbolType)],
) -> Option<RawSymbol> {
let mut cursor = node.walk();
let sym_lits: Vec<_> = node
.children(&mut cursor)
.filter(|c| c.kind() == "sym_lit")
.collect();
if sym_lits.len() < 2 {
return None;
}
let keyword = sym_lits[0].utf8_text(source).ok()?;
let sym_type = keyword_types
.iter()
.find_map(|(keywords, ty)| keywords.contains(&keyword).then_some(*ty))?;
let name = sym_lits[1].utf8_text(source).ok().map(|s| s.to_string());
Some(RawSymbol::at(node, name, sym_type))
}
pub(super) fn extract_commonlisp_defun(
node: &tree_sitter::Node<'_>,
source: &[u8],
) -> Option<RawSymbol> {
let mut cursor = node.walk();
let name = node
.children(&mut cursor)
.find(|c| c.kind() == "defun_header")
.and_then(|header| {
let mut hcursor = header.walk();
header
.children(&mut hcursor)
.find(|c| c.kind() == "sym_lit")
.and_then(|s| s.utf8_text(source).ok().map(|t| t.to_string()))
});
Some(RawSymbol::at(node, name, SymbolType::Function))
}
pub(super) fn extract_elixir_name(node: &tree_sitter::Node<'_>, source: &[u8]) -> Option<String> {
let mut cursor = node.walk();
let mut args = None;
for child in node.children(&mut cursor) {
if child.kind() == "arguments" {
args = Some(child);
break;
}
}
if let Some(args_node) = args
&& args_node.named_child_count() > 0
&& let Some(first_arg) = args_node.named_child(0)
{
if first_arg.kind() == "call"
&& let Some(target) = first_arg.child_by_field_name("target")
{
return target.utf8_text(source).ok().map(|s| s.to_string());
}
let mut inner_cursor = first_arg.walk();
for child in first_arg.children(&mut inner_cursor) {
if child.kind() == "identifier" || child.kind() == "alias" {
return child.utf8_text(source).ok().map(|s| s.to_string());
}
}
return first_arg.utf8_text(source).ok().map(|s| s.to_string());
}
None
}
pub(super) fn get_elixir_do_block<'a>(
node: &tree_sitter::Node<'a>,
) -> Option<tree_sitter::Node<'a>> {
let mut cursor = node.walk();
node.children(&mut cursor)
.find(|child| child.kind() == "do_block")
}
pub(super) fn extract_js_function_binding(
node: &tree_sitter::Node<'_>,
source: &[u8],
) -> Option<RawSymbol> {
let mut cursor = node.walk();
let mut declarators = node
.children(&mut cursor)
.filter(|child| child.kind() == "variable_declarator");
let declarator = declarators.next()?;
if declarators.next().is_some() {
return None;
}
let value = declarator.child_by_field_name("value")?;
if !matches!(
value.kind(),
"arrow_function" | "function_expression" | "generator_function"
) {
return None;
}
let name = extract_name(&declarator, source)?;
Some(RawSymbol::at(node, Some(name), SymbolType::Function))
}
pub(super) fn extract_lua_function_binding(
node: &tree_sitter::Node<'_>,
source: &[u8],
) -> Option<RawSymbol> {
let assignment = if node.kind() == "variable_declaration" {
let mut cursor = node.walk();
node.named_children(&mut cursor)
.find(|child| child.kind() == "assignment_statement")?
} else {
*node
};
let mut cursor = assignment.walk();
let children: Vec<_> = assignment.named_children(&mut cursor).collect();
let [variable_list, expression_list] = children.as_slice() else {
return None;
};
if variable_list.kind() != "variable_list" || expression_list.kind() != "expression_list" {
return None;
}
let mut variable_cursor = variable_list.walk();
let variables: Vec<_> = variable_list.named_children(&mut variable_cursor).collect();
let [variable] = variables.as_slice() else {
return None;
};
let mut value_cursor = expression_list.walk();
let values: Vec<_> = expression_list.named_children(&mut value_cursor).collect();
let [value] = values.as_slice() else {
return None;
};
if value.kind() != "function_definition" {
return None;
}
let name = match variable.kind() {
"identifier" => variable.utf8_text(source).ok()?.to_string(),
"dot_index_expression" => variable
.child_by_field_name("field")?
.utf8_text(source)
.ok()?
.to_string(),
"method_index_expression" => variable
.child_by_field_name("method")?
.utf8_text(source)
.ok()?
.to_string(),
_ => return None,
};
Some(RawSymbol::at(node, Some(name), SymbolType::Function))
}
pub(super) fn extract_bash_case_items(
function_node: &tree_sitter::Node<'_>,
source: &[u8],
symbols: &mut Vec<RawSymbol>,
) {
let function_name = extract_name(function_node, source);
symbols.push(RawSymbol::at(
function_node,
function_name.clone(),
SymbolType::Function,
));
fn visit(
node: tree_sitter::Node<'_>,
source: &[u8],
function_name: Option<&str>,
symbols: &mut Vec<RawSymbol>,
) {
if node.kind() == "case_statement" {
let mut cursor = node.walk();
for item in node
.named_children(&mut cursor)
.filter(|child| child.kind() == "case_item")
{
let mut value_cursor = item.walk();
let Some(pattern) = item
.children_by_field_name("value", &mut value_cursor)
.next()
.and_then(|value| value.utf8_text(source).ok())
.and_then(bash_case_pattern_name)
else {
continue;
};
let name = function_name
.map(|parent| format!("{parent} {pattern}"))
.unwrap_or(pattern);
symbols.push(RawSymbol::at(&item, Some(name), SymbolType::Function));
}
}
let mut cursor = node.walk();
for child in node.named_children(&mut cursor) {
if child.kind() != "function_definition" {
visit(child, source, function_name, symbols);
}
}
}
let mut cursor = function_node.walk();
for child in function_node.named_children(&mut cursor) {
visit(child, source, function_name.as_deref(), symbols);
}
}
fn bash_case_pattern_name(text: &str) -> Option<String> {
let text = text.trim();
if text.len() >= 2
&& matches!(
(text.as_bytes().first(), text.as_bytes().last()),
(Some(b'\''), Some(b'\'')) | (Some(b'"'), Some(b'"'))
)
{
let text = &text[1..text.len() - 1];
return (!text.is_empty()).then(|| text.to_string());
}
(!text.is_empty()).then(|| text.to_string())
}
pub(super) fn refine_go_type_spec(node: &tree_sitter::Node<'_>, source: &[u8]) -> SymbolType {
if let Some(type_child) = node.child_by_field_name("type") {
match type_child.kind() {
"struct_type" => return SymbolType::Struct,
"interface_type" => return SymbolType::Interface,
_ => {}
}
}
let text = node.utf8_text(source).unwrap_or("");
if text.contains("struct") {
SymbolType::Struct
} else if text.contains("interface") {
SymbolType::Interface
} else {
SymbolType::TypeAlias
}
}
pub(super) fn extract_rust_block_methods(
block_node: tree_sitter::Node<'_>,
source: &[u8],
lang: Language,
symbols: &mut Vec<RawSymbol>,
container_type: SymbolType,
) {
let name = extract_name(&block_node, source);
symbols.push(RawSymbol::at(&block_node, name, container_type));
let mut cursor = block_node.walk();
for child in block_node.children(&mut cursor) {
if child.kind() == "declaration_list" {
let mut inner_cursor = child.walk();
for item in child.children(&mut inner_cursor) {
if item.kind() == "function_item" {
let name = extract_name(&item, source);
symbols.push(RawSymbol::at(&item, name, SymbolType::Method));
} else if let Some(sym_type) = classify_node(lang, item.kind()) {
let name = extract_name(&item, source);
symbols.push(RawSymbol::at(&item, name, sym_type));
}
}
}
}
}
pub(super) fn extract_python_class_methods(
class_node: tree_sitter::Node<'_>,
source: &[u8],
symbols: &mut Vec<RawSymbol>,
) {
let name = extract_name(&class_node, source);
symbols.push(RawSymbol::at(&class_node, name, SymbolType::Class));
let mut cursor = class_node.walk();
for child in class_node.children(&mut cursor) {
if child.kind() == "block" {
let mut inner_cursor = child.walk();
for item in child.children(&mut inner_cursor) {
if item.kind() == "function_definition" {
let name = extract_name(&item, source);
symbols.push(RawSymbol::at(&item, name, SymbolType::Method));
}
else if item.kind() == "decorated_definition" {
let mut dec_cursor = item.walk();
for dec_child in item.children(&mut dec_cursor) {
if dec_child.kind() == "function_definition" {
let name = extract_name(&dec_child, source);
symbols.push(RawSymbol {
name,
symbol_type: SymbolType::Method,
start_byte: item.start_byte(),
end_byte: item.end_byte(),
start_row: item.start_position().row,
end_row: item.end_position().row,
});
}
}
}
}
}
}
}
pub(super) fn extract_general_class_methods(
class_node: tree_sitter::Node<'_>,
source: &[u8],
lang: Language,
symbols: &mut Vec<RawSymbol>,
class_sym_type: SymbolType,
) {
let name = extract_name(&class_node, source);
symbols.push(RawSymbol::at(&class_node, name, class_sym_type));
let mut cursor = class_node.walk();
for child in class_node.children(&mut cursor) {
let ckind = child.kind();
if ckind.contains("body") || ckind.contains("block") || ckind == "declaration_list" {
let mut inner_cursor = child.walk();
for item in child.children(&mut inner_cursor) {
if let Some(sym_type) = classify_node(lang, item.kind()) {
let mut end_byte = item.end_byte();
let mut end_row = item.end_position().row;
if lang == Language::Dart
&& item.kind() == "method_signature"
&& let Some(next) = item.next_sibling()
&& next.kind() == "function_body"
{
end_byte = next.end_byte();
end_row = next.end_position().row;
}
let name = extract_name(&item, source);
symbols.push(RawSymbol {
name,
symbol_type: sym_type,
start_byte: item.start_byte(),
end_byte,
start_row: item.start_position().row,
end_row,
});
} else if lang == Language::Dart && item.kind() == "class_member" {
let mut cm_cursor = item.walk();
for cm_child in item.children(&mut cm_cursor) {
if let Some(sym_type) = classify_node(lang, cm_child.kind()) {
let mut end_byte = cm_child.end_byte();
let mut end_row = cm_child.end_position().row;
if cm_child.kind() == "method_signature"
&& let Some(next) = cm_child.next_sibling()
&& next.kind() == "function_body"
{
end_byte = next.end_byte();
end_row = next.end_position().row;
}
let name = extract_name(&cm_child, source);
symbols.push(RawSymbol {
name,
symbol_type: sym_type,
start_byte: cm_child.start_byte(),
end_byte,
start_row: cm_child.start_position().row,
end_row,
});
}
}
} else if lang == Language::Java && class_sym_type == SymbolType::Enum {
let mut java_cursor = item.walk();
for java_child in item.children(&mut java_cursor) {
if let Some(sym_type) = classify_node(lang, java_child.kind()) {
let name = extract_name(&java_child, source);
symbols.push(RawSymbol::at(&java_child, name, sym_type));
continue;
}
let mut java_inner_cursor = java_child.walk();
for java_inner in java_child.children(&mut java_inner_cursor) {
if let Some(sym_type) = classify_node(lang, java_inner.kind()) {
let name = extract_name(&java_inner, source);
symbols.push(RawSymbol::at(&java_inner, name, sym_type));
}
}
}
}
}
}
}
}