popertots/ragmcp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix rust

Browse Source
This commit is contained in:
popertots
2025-11-16 00:15:45 +00:00
parent 862c372310
commit 1f21146c5d
1 changed files with 54 additions and 114 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tools/src/main.rs
+54 -114
View File
@@ -1,4 +1,3 @@
// tools/src/main.rs
use quote::ToTokens;
use regex::Regex;
use serde::Serialize;
@@ -7,7 +6,7 @@ use std::fs;
use std::process;
use syn::{
spanned::Spanned, Attribute, FnArg, Item, ItemEnum, ItemFn, ItemImpl, ItemMod, ItemStruct,
ItemTrait, Pat, Type, UseTree, UseTreeKind, Visibility,
ItemTrait, Pat, Type, UseTree, Visibility,
};
#[derive(Serialize)]
@@ -26,8 +25,8 @@ struct RustDecl {
return_type: Option<String>,
parameters: Vec<String>,
docstring: Option<String>,
imports: Vec<String>, // Track imports for cross-file relationships
calls: Vec<String>, // Track function calls
imports: Vec<String>,
calls: Vec<String>,
}
fn main() {
@@ -55,7 +54,7 @@ fn main() {
};
let mut decls = Vec::new();
let mut imports = Vec::new(); // Collect imports separately
let mut imports = Vec::new();
// Process imports first
for item in &syntax.items {
@@ -63,7 +62,7 @@ fn main() {
let import_paths = extract_use_paths(&item_use.tree);
imports.extend(import_paths.clone());
for path in &import_paths {
for path in import_paths {
decls.push(RustDecl {
name: path.clone(),
type_: "import".to_string(),
@@ -86,12 +85,12 @@ fn main() {
}
}
// Process other declarations with import context
// Process other declarations
for item in &syntax.items {
match item {
Item::Fn(item_fn) => {
if let Some(mut decl) = parse_function(&item_fn, &content) {
decl.imports = imports.clone(); // Add imports to function context
decl.imports = imports.clone();
decls.push(decl);
}
}
@@ -114,7 +113,7 @@ fn main() {
}
}
Item::Impl(item_impl) => {
if let Some(mut decl) = parse_impl(&item_impl, &content) {
if let Some(mut decl) = parse_impl(&item_impl) {
decl.imports = imports.clone();
decls.push(decl);
}
@@ -133,7 +132,7 @@ fn main() {
println!("{}", output);
}
// Better span handling (requires proc-macro2 "span-locations" feature)
// Fixed span handling
fn get_span_start(span: &proc_macro2::Span) -> usize {
span.start().line
}
@@ -142,7 +141,7 @@ fn get_span_end(span: &proc_macro2::Span) -> usize {
span.end().line
}
// Enhanced import extraction
// Fixed import extraction
fn extract_use_paths(tree: &UseTree) -> Vec<String> {
let mut paths = Vec::new();
extract_use_paths_recursive(tree, "", &mut paths);
@@ -178,9 +177,6 @@ fn extract_use_paths_recursive(tree: &UseTree, current_path: &str, paths: &mut V
UseTree::Glob(_) => {
if !current_path.is_empty() {
paths.push(format!("{}::*", current_path));
} else {
// top-level glob — represent as "*"
paths.push("*".to_string());
}
}
UseTree::Group(group) => {
@@ -188,12 +184,10 @@ fn extract_use_paths_recursive(tree: &UseTree, current_path: &str, paths: &mut V
extract_use_paths_recursive(item, current_path, paths);
}
}
// If the AST contains other nodes, ignore them (keeps function exhaustive)
_ => {}
}
}
// Enhanced function parsing with call detection
// Fixed function parsing
fn parse_function(item_fn: &ItemFn, file_content: &str) -> Option<RustDecl> {
let start_line = get_span_start(&item_fn.span());
let end_line = get_span_end(&item_fn.span());
@@ -204,7 +198,7 @@ fn parse_function(item_fn: &ItemFn, file_content: &str) -> Option<RustDecl> {
let name = if let Pat::Ident(pat_ident) = &*pat_type.pat {
pat_ident.ident.to_string()
} else {
format!("{}", quote::ToTokens::to_token_stream(&pat_type.pat))
quote::ToTokens::to_token_stream(&pat_type.pat).to_string()
};
let ty = type_to_string(&*pat_type.ty);
parameters.push(format!("{}: {}", name, ty));
@@ -218,7 +212,6 @@ fn parse_function(item_fn: &ItemFn, file_content: &str) -> Option<RustDecl> {
syn::ReturnType::Type(_, ty) => Some(type_to_string(&*ty)),
};
// Extract function calls from body
let calls = extract_function_calls(&item_fn.block, file_content);
Some(RustDecl {
@@ -242,36 +235,28 @@ fn parse_function(item_fn: &ItemFn, file_content: &str) -> Option<RustDecl> {
return_type,
parameters,
docstring: extract_docstring(&item_fn.attrs),
imports: Vec::new(), // Filled by caller
imports: Vec::new(),
calls,
})
}
// Simple function call extraction using regex on tokenized block
// Fixed function call extraction
fn extract_function_calls(block: &syn::Block, _file_content: &str) -> Vec<String> {
let mut calls = Vec::new();
let content = quote::ToTokens::to_token_stream(block).to_string();
// Basic regex to find function-like identifiers followed by '('
let re = Regex::new(r"\b([a-zA-Z_][a-zA-Z0-9_]*)\s*\(").unwrap();
for cap in re.captures_iter(&content) {
if let Some(name) = cap.get(1) {
let call = name.as_str().to_string();
// Filter out common keywords and types, and constructors (capitalized)
if !is_rust_keyword(&call) && !call.chars().next().map_or(false, |c| c.is_uppercase()) {
calls.push(call);
}
}
}
// Deduplicate while preserving order
let mut deduped = Vec::new();
for c in calls {
if !deduped.contains(&c) {
deduped.push(c);
}
}
deduped
calls.dedup();
calls
}
fn is_rust_keyword(word: &str) -> bool {
@@ -313,14 +298,10 @@ fn is_rust_keyword(word: &str) -> bool {
| "box"
| "true"
| "false"
| "Some"
| "None"
| "Ok"
| "Err"
)
}
// Update other parse functions to include the new fields...
// Fixed struct parsing
fn parse_struct(item_struct: &ItemStruct) -> Option<RustDecl> {
let start_line = get_span_start(&item_struct.span());
let end_line = get_span_end(&item_struct.span());
@@ -329,7 +310,6 @@ fn parse_struct(item_struct: &ItemStruct) -> Option<RustDecl> {
.fields
.iter()
.filter_map(|field| {
// field.ident is Option<Ident> for named fields; for tuple structs it's None
field.ident.as_ref().map(|ident| {
let field_name = ident.to_string();
let field_type = type_to_string(&field.ty);
@@ -358,11 +338,12 @@ fn parse_struct(item_struct: &ItemStruct) -> Option<RustDecl> {
return_type: None,
parameters: Vec::new(),
docstring: extract_docstring(&item_struct.attrs),
imports: Vec::new(), // Filled by caller
imports: Vec::new(),
calls: Vec::new(),
})
}
// Fixed enum parsing
fn parse_enum(item_enum: &ItemEnum) -> Option<RustDecl> {
let start_line = get_span_start(&item_enum.span());
let end_line = get_span_end(&item_enum.span());
@@ -398,6 +379,7 @@ fn parse_enum(item_enum: &ItemEnum) -> Option<RustDecl> {
})
}
// Fixed trait parsing
fn parse_trait(item_trait: &ItemTrait) -> Option<RustDecl> {
let start_line = get_span_start(&item_trait.span());
let end_line = get_span_end(&item_trait.span());
@@ -439,7 +421,8 @@ fn parse_trait(item_trait: &ItemTrait) -> Option<RustDecl> {
})
}
fn parse_impl(item_impl: &ItemImpl, file_content: &str) -> Option<RustDecl> {
// Fixed impl parsing
fn parse_impl(item_impl: &ItemImpl) -> Option<RustDecl> {
let start_line = get_span_start(&item_impl.span());
let end_line = get_span_end(&item_impl.span());
@@ -457,34 +440,19 @@ fn parse_impl(item_impl: &ItemImpl, file_content: &str) -> Option<RustDecl> {
})
.collect();
// If this impl implements a trait, extract its path
let implements: Vec<String> = item_impl
let implements = item_impl
.trait_
.as_ref()
.map(|(_, path, _)| path_to_string(path))
.into_iter()
.collect();
.collect::<Vec<_>>();
// Prefer the first trait name (if any) as the identifier; otherwise fall back to the target type
let name = if !implements.is_empty() {
implements[0].clone()
} else {
target.clone()
target
};
// Extract calls across all method bodies in the impl (basic)
let mut calls = Vec::new();
for item in &item_impl.items {
if let syn::ImplItem::Fn(method) = item {
let body_calls = extract_function_calls(&method.block, file_content);
for c in body_calls {
if !calls.contains(&c) {
calls.push(c);
}
}
}
}
let docstring = extract_docstring(&item_impl.attrs);
Some(RustDecl {
@@ -508,10 +476,11 @@ fn parse_impl(item_impl: &ItemImpl, file_content: &str) -> Option<RustDecl> {
parameters: Vec::new(),
docstring,
imports: Vec::new(),
calls,
calls: Vec::new(),
})
}
// Fixed mod parsing
fn parse_mod(item_mod: &ItemMod) -> Option<RustDecl> {
let start_line = get_span_start(&item_mod.span());
let end_line = get_span_end(&item_mod.span());
@@ -536,13 +505,36 @@ fn parse_mod(item_mod: &ItemMod) -> Option<RustDecl> {
})
}
// Fixed docstring extraction
fn extract_docstring(attrs: &[Attribute]) -> Option<String> {
let text = attrs
.iter()
.map(|a| a.to_token_stream().to_string())
.collect::<Vec<_>>()
.join("\n");
let re = Regex::new(r#"(?m)^\s*(?:///|#\[\s*doc\s*=\s*")(.+?)(?:")?$"#).unwrap();
let mut doc_lines = Vec::new();
for line in text.lines() {
if let Some(caps) = re.captures(line) {
if let Some(m) = caps.get(1) {
doc_lines.push(m.as_str().to_string());
}
}
}
if doc_lines.is_empty() {
None
} else {
Some(doc_lines.join("\n"))
}
}
fn visibility_to_string(vis: &Visibility) -> String {
match vis {
Visibility::Public(_) => "pub".to_string(),
Visibility::Restricted(r) => {
// pub(crate) or pub(in ...)
quote::ToTokens::to_token_stream(r).to_string()
}
Visibility::Restricted(_) => "pub(restricted)".to_string(),
_ => "private".to_string(),
}
}
@@ -559,10 +551,6 @@ fn type_to_string(ty: &Type) -> String {
Type::Reference(type_ref) => {
format!("&{}", type_to_string(&*type_ref.elem))
}
Type::Tuple(tuple) => {
let elems: Vec<String> = tuple.elems.iter().map(type_to_string).collect();
format!("({})", elems.join(", "))
}
_ => quote::ToTokens::to_token_stream(ty).to_string(),
}
}
@@ -582,51 +570,3 @@ fn generic_param_to_string(param: &syn::GenericParam) -> String {
syn::GenericParam::Const(cnst) => cnst.ident.to_string(),
}
}
/// Pull a concatenated doc-string from a list of attributes.
/// Handles both `///` comments (converted to `#[doc = "..."]` by syn)
/// and explicit `#[doc = "..."]` attributes.
fn extract_docstring(attrs: &[Attribute]) -> Option<String> {
// Prefer parsing doc attributes explicitly
let mut lines: Vec<String> = Vec::new();
for attr in attrs {
// If attribute path is "doc", try to parse the meta and extract the literal
if attr.path().is_ident("doc") {
if let Ok(syn::Meta::NameValue(nv)) = attr.parse_meta() {
if let syn::Lit::Str(litstr) = nv.lit {
lines.push(litstr.value());
}
} else {
// Fallback: stringify the tokens and try regex extraction
let tok = attr.to_token_stream().to_string();
let re = Regex::new(r#"(?m)#\s*\[\s*doc\s*=\s*"(.+?)"\s*\]"#).ok();
if let Some(re) = re {
if let Some(cap) = re.captures(&tok) {
if let Some(m) = cap.get(1) {
lines.push(m.as_str().to_string());
}
}
}
}
} else {
// capture leading "///" style comments as attributes may not always be "doc"
let tok = attr.to_token_stream().to_string();
// crude fallback to capture /// "..." inside tokens
let re_line = Regex::new(r#"(?m)///\s*(.+)$"#).ok();
if let Some(re_line) = re_line {
for cap in re_line.captures_iter(&tok) {
if let Some(m) = cap.get(1) {
lines.push(m.as_str().to_string());
}
}
}
}
}
if lines.is_empty() {
None
} else {
Some(lines.join("\n"))
}
}