Track parsed URIs to avoid redundant file parsing

Author: AJenbo

src/definition/implementation.rs

@@ -707,7 +707,7 @@ impl Backend {
         // Phase 1 and can be skipped.
         let classmap_paths: HashSet<PathBuf> = self.classmap.read().values().cloned().collect();
 
-        let loaded_uris: HashSet<String> = self.ast_map.read().keys().cloned().collect();
+        let loaded_uris: HashSet<String> = self.parsed_uris.read().iter().cloned().collect();
 
         for path in &classmap_paths {
             let uri = crate::util::path_to_uri(path);
@@ -802,8 +802,7 @@ impl Backend {
                     .collect()
             };
 
-            // Refresh loaded URIs — Phase 3 may have added entries.
-            let loaded_uris_p5: HashSet<String> = self.ast_map.read().keys().cloned().collect();
+            let loaded_uris_p5: HashSet<String> = self.parsed_uris.read().iter().cloned().collect();
 
             for dir in &psr4_dirs {
                 for php_file in collect_php_files(dir, &vendor_dir_paths) {

src/definition/resolve.rs

@@ -512,7 +512,7 @@ impl Backend {
             let mut lazy_result = None;
             for path in &paths {
                 let uri = crate::util::path_to_uri(path);
-                if self.ast_map.read().contains_key(&uri) {
+                if self.parsed_uris.read().contains(&uri) {
                     continue;
                 }
 
@@ -655,13 +655,11 @@ impl Backend {
     ) -> Option<Location> {
         let target_uri_string = crate::util::path_to_uri(file_path);
 
-        // Ensure the file is parsed and cached.  If the file is already in
-        // `ast_map` (opened via `did_open`, loaded from autoload files, or
-        // parsed in a previous cross-file jump), `parse_and_cache_file`
-        // will re-parse it — but the cost is negligible compared to the
-        // disk I/O we'd do anyway.  A future optimisation can skip the
-        // re-parse when an `ast_map` entry already exists.
-        let already_cached = self.ast_map.read().contains_key(&target_uri_string);
+        // Ensure the file is parsed and cached.  If the file has
+        // already been parsed (opened via `did_open`, loaded from
+        // autoload files, or parsed in a previous cross-file jump),
+        // skip re-parsing.
+        let already_cached = self.parsed_uris.read().contains(&target_uri_string);
 
         if !already_cached {
             self.parse_and_cache_file(file_path);

src/hover/mod.rs

@@ -864,7 +864,7 @@ impl Backend {
             let paths = self.autoload_file_paths.read().clone();
             for path in &paths {
                 let uri = crate::util::path_to_uri(path);
-                if self.ast_map.read().contains_key(&uri) {
+                if self.parsed_uris.read().contains(&uri) {
                     continue;
                 }
                 if let Ok(content) = std::fs::read_to_string(path) {

src/lib.rs

@@ -343,6 +343,14 @@ pub struct Backend {
     /// classmap contains a phar-based path (detected by a `!` separator,
     /// e.g. `/path/to/phpstan.phar!src/Type/Type.php`).
     pub(crate) phar_archives: Arc<RwLock<HashMap<PathBuf, phar::PharArchive>>>,
+    /// Set of file URIs that have been fully parsed at least once.
+    ///
+    /// Used as a lightweight "has this file been parsed?" check by
+    /// consumers that need to skip redundant re-parsing (e.g.
+    /// `find_or_load_function`, `resolve_constant_definition`,
+    /// `find_implementors`).  Populated in `update_ast_inner` and
+    /// `parse_and_cache_content_versioned`.
+    pub(crate) parsed_uris: Arc<RwLock<HashSet<String>>>,
     /// Set of file URIs currently being parsed by another thread.
     ///
     /// Used by [`parse_and_cache_file`](Self::parse_and_cache_file) to avoid
@@ -655,6 +663,7 @@ impl Backend {
             class_not_found_cache: Arc::new(RwLock::new(HashSet::new())),
             classmap: Arc::new(RwLock::new(HashMap::new())),
             phar_archives: Arc::new(RwLock::new(HashMap::new())),
+            parsed_uris: Arc::new(RwLock::new(HashSet::new())),
             parse_inflight: Arc::new(Mutex::new(HashSet::new())),
             stub_index: RwLock::new(stubs::build_stub_class_index()),
             stub_function_index: RwLock::new(stubs::build_stub_function_index()),
@@ -732,6 +741,7 @@ impl Backend {
             class_not_found_cache: Arc::new(RwLock::new(HashSet::new())),
             classmap: Arc::new(RwLock::new(HashMap::new())),
             phar_archives: Arc::new(RwLock::new(HashMap::new())),
+            parsed_uris: Arc::new(RwLock::new(HashSet::new())),
             parse_inflight: Arc::new(Mutex::new(HashSet::new())),
             stub_index: RwLock::new(HashMap::new()),
             stub_function_index: RwLock::new(HashMap::new()),
@@ -1081,6 +1091,7 @@ impl Backend {
             fqn_index: Arc::clone(&self.fqn_index),
             classmap: Arc::clone(&self.classmap),
             phar_archives: Arc::clone(&self.phar_archives),
+            parsed_uris: Arc::clone(&self.parsed_uris),
             parse_inflight: Arc::clone(&self.parse_inflight),
             class_not_found_cache: Arc::clone(&self.class_not_found_cache),
             stub_index: RwLock::new(self.stub_index.read().clone()),

src/parser/ast_update.rs

@@ -516,6 +516,7 @@ impl Backend {
             uri_string.clone(),
             classes.into_iter().map(Arc::new).collect(),
         );
+        self.parsed_uris.write().insert(uri_string.clone());
 
         // Populate the global method store for O(1) method lookup.
         self.evict_methods_for_fqns(&old_fqns);

src/resolution.rs

@@ -435,19 +435,25 @@ impl Backend {
         // Wrap each ClassInfo in Arc before inserting into the maps.
         let arc_classes: Vec<Arc<ClassInfo>> = classes.into_iter().map(Arc::new).collect();
 
-        // Check whether this URI already has an ast_map entry before
-        // we overwrite it.  Used below to decide whether resolved-class
-        // cache eviction is needed (only on re-parse, not first load).
-        let was_already_parsed = self.ast_map.read().contains_key(uri);
+        // Check whether this URI already has been parsed before.
+        // Used below to decide whether resolved-class cache eviction
+        // is needed (only on re-parse, not first load).
+        let was_already_parsed = self.parsed_uris.read().contains(uri);
 
+        // Record that this URI has been parsed.
+        self.parsed_uris.write().insert(uri.to_owned());
+
+        // Store in ast_map for wait_for_cached_result (concurrent
+        // parse deduplication) and for consumers that iterate classes
+        // by URI.  The memory cost is negligible (just Arc pointers).
         self.ast_map
             .write()
             .insert(uri.to_owned(), arc_classes.clone());
         // NOTE: use_map and namespace_map are intentionally NOT stored
         // for lazily-loaded files (vendor, stubs, PSR-4).  These maps
         // are only needed for files open in the editor (populated by
         // update_ast_inner).  Skipping them reduces memory usage across
-        // thousands of vendor files.  See P13 (tiered storage).
+        // thousands of vendor files.  See P13.
 
         // Populate the fqn_index so that `find_class_in_ast_map` can
         // resolve these classes via O(1) hash lookup.
@@ -595,7 +601,7 @@ impl Backend {
                 // Skip files that have already been fully parsed (their
                 // functions are already in global_functions via Phase 1).
                 let uri = crate::util::path_to_uri(path);
-                if self.ast_map.read().contains_key(&uri) {
+                if self.parsed_uris.read().contains(&uri) {
                     continue;
                 }