Method scan_phar_archive

src/server.rs:1967–2043

Parse a `.phar` archive and register its PHP classes in the fqn_uri_index for lazy loading. The phar's raw bytes are read from disk, parsed by [`phar::PharArchive`], and stored in [`phar_archives`](crate::Backend::phar_archives). Each `.php` file inside the archive is scanned with the lightweight [`find_classes`](classmap_scanner::find_classes) byte scanner, and discovered classes are registered

(&self, phar_path: &Path)

    ///   to extract content from the phar instead of reading from disk)
    ///   and a `phar://` URI for completions and workspace symbols
    fn scan_phar_archive(&self, phar_path: &Path) {
        // Avoid scanning the same phar twice.
        if self.phar_archives.read().contains_key(phar_path) {
            return;
        }

        let data = match std::fs::read(phar_path) {
            Ok(d) => d,
            Err(_) => return,
        };

        let archive = match phar::PharArchive::parse(data) {
            Some(a) => a,
            None => {
                tracing::warn!("failed to parse phar archive: {}", phar_path.display());
                return;
            }
        };

        // Collect PHP file paths first so we can iterate while
        // holding the archive reference.
        let php_files: Vec<String> = archive
            .file_paths()
            .filter(|p| p.ends_with(".php"))
            .map(String::from)
            .collect();

        let mut classmap_entries: Vec<(String, PathBuf)> = Vec::new();
        let mut fqn_uri_entries: Vec<(String, String)> = Vec::new();

        for internal_path in &php_files {
            if let Some(content) = archive.read_file(internal_path) {
                let classes = classmap_scanner::find_classes(content);
                for fqn in classes {
                    // Sentinel path: "archive.phar!internal/path.php"
                    let sentinel =
                        PathBuf::from(format!("{}!{}", phar_path.display(), internal_path));
                    let phar_uri = format!("phar://{}/{}", phar_path.display(), internal_path);
                    classmap_entries.push((fqn.clone(), sentinel));
                    fqn_uri_entries.push((fqn, phar_uri));
                }
            }
        }

        let class_count = classmap_entries.len();

        // Register classes in the fqn_uri_index.
        {
            let mut idx = self.fqn_uri_index.write();
            for (fqn, path) in classmap_entries {
                idx.entry(fqn)
                    .or_insert_with(|| crate::util::path_to_uri(&path));
            }
            for (fqn, uri) in fqn_uri_entries {
                idx.entry(fqn).or_insert(uri);
            }
        }