Merge parse_file

Author: owjs3901

crates/vespera_macro/src/collector.rs

@@ -50,14 +50,6 @@ pub fn collect_metadata(
             continue;
         }
 
-        let content = std::fs::read_to_string(&file).map_err(|e| {
-            err_call_site(format!(
-                "vespera! macro: failed to read route file '{}': {}. Check file permissions.",
-                file.display(),
-                e
-            ))
-        })?;
-
         let file_path = file.display().to_string();
 
         // Get module path (cheap — no parsing needed)
@@ -118,7 +110,9 @@ pub fn collect_metadata(
             // into SCHEMA_STORAGE.field_defaults (Priority 0 in process_default_functions)
         } else {
             // Slow path: full parsing (fallback for files not in ROUTE_STORAGE)
-            let file_ast = syn::parse_file(&content).map_err(|e| err_call_site(format!("vespera! macro: syntax error in '{}': {}. Fix the Rust syntax errors in this file.", file.display(), e)))?;
+            // Uses get_parsed_file: single syn::parse_file entry point + content cache
+            let file_ast = crate::schema_macro::file_cache::get_parsed_file(&file)
+                .ok_or_else(|| err_call_site(format!("vespera! macro: cannot read or parse '{}'. Fix the Rust syntax errors in this file.", file.display())))?;
 
             // Store file AST for downstream reuse
             file_asts.insert(file_path.clone(), file_ast);

crates/vespera_macro/src/file_utils.rs

@@ -3,35 +3,6 @@ use std::{
     path::{Path, PathBuf},
 };
 
-/// Read and parse a Rust source file, printing warnings on error.
-#[allow(clippy::similar_names)]
-pub fn read_and_parse_file_warn(path: &Path, context: &str) -> Option<syn::File> {
-    let content = match std::fs::read_to_string(path) {
-        Ok(c) => c,
-        Err(e) => {
-            eprintln!(
-                "Warning: {}: Cannot read '{}': {}",
-                context,
-                path.display(),
-                e
-            );
-            return None;
-        }
-    };
-    match syn::parse_file(&content) {
-        Ok(ast) => Some(ast),
-        Err(e) => {
-            eprintln!(
-                "Warning: {}: Parse error in '{}': {}",
-                context,
-                path.display(),
-                e
-            );
-            None
-        }
-    }
-}
-
 pub fn collect_files(folder_path: &Path) -> io::Result<Vec<PathBuf>> {
     let mut files = Vec::new();
     for entry in std::fs::read_dir(folder_path)? {

crates/vespera_macro/src/openapi_generator.rs

@@ -10,7 +10,6 @@ use vespera_core::{
 };
 
 use crate::{
-    file_utils::read_and_parse_file_warn,
     metadata::CollectedMetadata,
     parser::{
         build_operation_from_function, extract_default, extract_field_rename, extract_rename_all,
@@ -129,7 +128,7 @@ fn build_file_cache(metadata: &CollectedMetadata) -> HashMap<String, syn::File>
         .collect();
     let mut cache = HashMap::with_capacity(unique_paths.len());
     for path in unique_paths {
-        if let Some(ast) = read_and_parse_file_warn(Path::new(path), "OpenAPI generation") {
+        if let Some(ast) = crate::schema_macro::file_cache::get_parsed_file(Path::new(path)) {
             cache.insert(path.to_string(), ast);
         }
     }

crates/vespera_macro/src/schema_impl.rs

@@ -121,11 +121,8 @@ fn extract_field_defaults(input: &syn::DeriveInput) -> BTreeMap<String, serde_js
         return defaults;
     };
 
-    // Read and parse the file
-    let Some(file_ast) = crate::file_utils::read_and_parse_file_warn(
-        &file_path,
-        "derive(Schema) default extraction",
-    ) else {
+    // Read and parse the file (cached via FileCache parsed_file_asts)
+    let Some(file_ast) = crate::schema_macro::file_cache::get_parsed_file(&file_path) else {
         return defaults;
     };
 

crates/vespera_macro/src/schema_macro/file_cache.rs

@@ -33,10 +33,16 @@ struct FileCache {
     /// Built from cheap `String::contains` search, not full parsing.
     struct_candidates: HashMap<(PathBuf, String), Vec<PathBuf>>,
 
-    // NOTE: We do NOT cache `syn::ItemStruct` directly because `syn` types contain
-    // `proc_macro::Span` handles tied to a specific macro invocation context.
+    // NOTE: We CANNOT cache `syn::File` or `syn::ItemStruct` across proc-macro
+    // invocations. Both `syn` and `proc_macro2` types contain `proc_macro::Span`
+    // and `proc_macro::TokenStream` bridge handles allocated in the current
+    // invocation's bridge context. Cloning them in a later invocation panics with
+    // "use-after-free in `proc_macro` handle".
+    //
     // Instead, `struct_definitions` caches extracted definition *strings* which have
-    // no Span handles and are safe to reuse across invocations.
+    // no bridge handles and are safe to reuse. For callers needing `syn::File`,
+    // `get_parsed_file()` caches the file *content* (safe string) and re-parses
+    // per invocation, avoiding redundant disk I/O while staying safe.
 
     // --- Profiling counters (zero-cost when VESPERA_PROFILE is not set) ---
     /// Number of file content reads from disk (cache miss).
@@ -112,6 +118,30 @@ pub fn get_manifest_dir() -> Option<String> {
     })
 }
 
+/// Get a parsed `syn::File` for the given path.
+///
+/// Uses the file content cache to avoid redundant disk I/O, then parses with
+/// `syn::parse_file` each time. We CANNOT cache `syn::File` across proc-macro
+/// invocations because `proc_macro2`/`syn` types contain `proc_macro::TokenStream`
+/// bridge handles that become invalid when the invocation that created them ends.
+pub fn get_parsed_file(path: &Path) -> Option<syn::File> {
+    FILE_CACHE.with(|cache| {
+        let mut cache = cache.borrow_mut();
+        parse_file_cached(&mut cache, path)
+    })
+}
+
+/// **Single call site for `syn::parse_file`.**
+///
+/// Reads file content from the mtime-validated content cache (avoids redundant
+/// disk I/O), then calls `syn::parse_file`. The resulting `syn::File` is NOT
+/// cached — it must be used and dropped within the current proc-macro invocation.
+fn parse_file_cached(cache: &mut FileCache, path: &Path) -> Option<syn::File> {
+    let content = get_file_content_inner(cache, path)?;
+    cache.ast_parses += 1;
+    syn::parse_file(&content).ok()
+}
+
 /// Get candidate files that likely contain `struct_name`, using cache when available.
 ///
 /// Performs a cheap text-based search (`String::contains`) on file contents.
@@ -165,12 +195,9 @@ fn ensure_struct_definitions(cache: &mut FileCache, path: &Path) -> bool {
         return true;
     }
 
-    // Cache miss — parse file and extract all struct definitions
-    let Some(content) = get_file_content_inner(cache, path) else {
-        return false;
-    };
-    cache.ast_parses += 1;
-    let Ok(file_ast) = syn::parse_file(&content) else {
+    // Cache miss — parse file and extract all struct definitions.
+    // Uses parse_file_cached: single syn::parse_file entry point.
+    let Some(file_ast) = parse_file_cached(cache, path) else {
         return false;
     };
 

crates/vespera_macro/src/schema_macro/mod.rs

@@ -6,7 +6,7 @@
 
 mod circular;
 mod codegen;
-mod file_cache;
+pub mod file_cache;
 mod file_lookup;
 mod from_model;
 mod inline_types;