Method find_class_references

src/references/mod.rs:608–744

Find all references to a class/interface/trait/enum across all files. Matches `ClassReference` spans whose resolved FQN equals `target_fqn`, and optionally `ClassDeclaration` spans at the declaration site.

(&self, target_fqn: &str, include_declaration: bool)

    /// Matches `ClassReference` spans whose resolved FQN equals `target_fqn`,
    /// and optionally `ClassDeclaration` spans at the declaration site.
    fn find_class_references(&self, target_fqn: &str, include_declaration: bool) -> Vec<Location> {
        let mut locations = Vec::new();

        // Normalise: strip leading backslash if present.
        let target = strip_fqn_prefix(target_fqn);
        let target_short = crate::util::short_name(target);

        // Snapshot user-file symbol maps (excludes vendor and stubs).
        let snapshot = self.user_file_symbol_maps();

        for (file_uri, symbol_map) in &snapshot {
            // Prefer mago-names resolved_names for FQN resolution (byte-offset
            // based, applies PHP's full name resolution rules).  Falls back to
            // the legacy use_map lazily for identifiers not tracked by
            // mago-names (e.g. docblock-sourced references).
            let resolved_names = self.resolved_names.read().get(file_uri).cloned();
            let file_namespace = self.first_file_namespace(file_uri);
            let file_use_map = std::cell::OnceCell::new();

            // First pass: resolved-name check to avoid unnecessary content work.
            // Aliased imports (`use Foo as Bar; new Bar`) must still reach the
            // full matching loop, because the textual span name is the alias.
            let has_potential_match = symbol_map.spans.iter().any(|span| match &span.kind {
                SymbolKind::ClassReference { name, .. } => {
                    if crate::util::short_name(name) == target_short {
                        true
                    } else {
                        let resolved = if let Some(fqn) =
                            resolved_names.as_ref().and_then(|rn| rn.get(span.start))
                        {
                            fqn.to_string()
                        } else {
                            let use_map = file_use_map.get_or_init(|| {
                                self.file_imports
                                    .read()
                                    .get(file_uri)
                                    .cloned()
                                    .unwrap_or_default()
                            });
                            Self::resolve_to_fqn(name, use_map, &file_namespace)
                        };
                        class_names_match(strip_fqn_prefix(&resolved), target, target_short)
                    }
                }
                SymbolKind::ClassDeclaration { name } => {
                    include_declaration && name == target_short
                }
                SymbolKind::SelfStaticParent(ssp_kind) => *ssp_kind != SelfStaticParentKind::This,
                _ => false,
            });

            if !has_potential_match {
                continue;
            }

            let parsed_uri = match Url::parse(file_uri) {
                Ok(u) => u,
                Err(_) => continue,