Method find_function_references

src/references/mod.rs:970–1087

Find all references to a function across all files.

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

    /// Find all references to a function across all files.
    fn find_function_references(
        &self,
        target_fqn: &str,
        target_short: &str,
        include_declaration: bool,
    ) -> Vec<Location> {
        let mut locations = Vec::new();

        // Input boundary: callers may pass FQNs with a leading `\`.
        let target = strip_fqn_prefix(target_fqn);

        let snapshot = self.user_file_symbol_maps();

        for (file_uri, symbol_map) in &snapshot {
            // Prefer mago-names resolved_names; lazy-load use_map only
            // when an offset is not tracked (e.g. docblock 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. Function imports can be aliased
            // (`use function Foo\bar as baz; baz()`), so the call-site text
            // alone is not enough to decide whether this file can match.
            let has_potential_match = symbol_map.spans.iter().any(|span| {
                if let SymbolKind::FunctionCall { name, .. } = &span.kind {
                    if 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)
                        };
                        let resolved_normalized = strip_fqn_prefix(&resolved);
                        resolved_normalized == target
                            || crate::util::short_name(resolved_normalized) == target_short
                    }
                } else {
                    false
                }
            });

            if !has_potential_match {
                continue;
            }

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