Method find_member_references

src/references/mod.rs:757–967

Find all references to a member (method, property, or constant) across all files. When `hierarchy` is `Some`, only references where the subject resolves to a class in the given set of FQNs are returned. When the subject cannot be resolved (e.g. a complex expression or an untyped variable), the reference is conservatively included. When `hierarchy` is `None`, all references with a matching membe

(
        &self,
        target_member: &str,
        target_is_static: bool,
        include_declaration: bool,
        hierarchy: Option<&HashSet<String>>,
    )

    /// name and static-ness are returned (the v1 behaviour, kept as a
    /// fallback when the target class cannot be determined).
    fn find_member_references(
        &self,
        target_member: &str,
        target_is_static: bool,
        include_declaration: bool,
        hierarchy: Option<&HashSet<String>>,
    ) -> Vec<Location> {
        let mut locations = Vec::new();

        let snapshot = self.user_file_symbol_maps();

        for (file_uri, symbol_map) in &snapshot {
            // First pass: name-only check to avoid unnecessary work.
            let has_potential_match = symbol_map.spans.iter().any(|span| match &span.kind {
                SymbolKind::MemberAccess {
                    member_name,
                    is_static,
                    ..
                } if member_name == target_member && *is_static == target_is_static => true,
                SymbolKind::MemberDeclaration { name, is_static }
                    if include_declaration
                        && name == target_member
                        && *is_static == target_is_static =>
                {
                    true
                }
                _ => false,
            });

            // Special check for property declarations in ClassInfo (represented as Variable spans)
            let mut check_ast_map = false;
            if !has_potential_match
                && include_declaration
                && let Some(classes) = self.get_classes_for_uri(file_uri)
            {
                for class in &classes {
                    for prop in &class.properties {
                        let prop_name = prop.name.strip_prefix('$').unwrap_or(&prop.name);
                        let target_name = target_member.strip_prefix('$').unwrap_or(target_member);
                        if prop_name == target_name && prop.is_static == target_is_static {
                            check_ast_map = true;
                            break;
                        }
                    }
                    if check_ast_map {
                        break;
                    }
                }
            }

            if !has_potential_match && !check_ast_map {
                continue;
            }

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