Method resolve_reverse_implementation

src/definition/implementation.rs:209–304

Reverse jump: from a method definition in a concrete class to the interface or abstract class that declares the prototype. When the cursor is on a method name at its definition site (e.g. `public function handle()` in a class that implements `Handler`), this finds the interface/abstract method declaration and returns its location.

(
        &self,
        uri: &str,
        content: &str,
        current_class: &ClassInfo,
        member_name: &str,
        class_loader: &dyn Fn(&str) -> Option<Arc<ClassInfo>>,
    )

    /// this finds the interface/abstract method declaration and returns
    /// its location.
    fn resolve_reverse_implementation(
        &self,
        uri: &str,
        content: &str,
        current_class: &ClassInfo,
        member_name: &str,
        class_loader: &dyn Fn(&str) -> Option<Arc<ClassInfo>>,
    ) -> Option<Vec<Location>> {
        // For interfaces and abstract classes, the forward direction
        // applies: find concrete implementors that define the method.
        if current_class.kind == ClassLikeKind::Interface || current_class.is_abstract {
            return self.resolve_interface_member_implementations(
                uri,
                content,
                current_class,
                member_name,
                class_loader,
            );
        }

        let mut locations = Vec::new();

        // Check implemented interfaces for a method with the same name.
        let all_ifaces = self.collect_all_interfaces(current_class, class_loader);
        for iface_name in &all_ifaces {
            if let Some(iface) = class_loader(iface_name) {
                let has_member = iface.has_method(member_name)
                    || iface.properties.iter().any(|p| p.name == member_name);
                if has_member {
                    let member_kind = if iface.has_method(member_name) {
                        MemberKind::Method
                    } else {
                        MemberKind::Property
                    };
                    if let Some((class_uri, class_content)) =
                        self.find_class_file_content(iface_name, uri, content)
                        && let Some(member_pos) = Self::find_member_position_in_class(
                            &class_content,
                            member_name,
                            member_kind,
                            &iface,
                        )
                        && let Ok(parsed_uri) = Url::parse(&class_uri)
                    {
                        let loc = point_location(parsed_uri, member_pos);
                        if !locations.contains(&loc) {
                            locations.push(loc);
                        }
                    }
                }
            }
        }

        // Check parent abstract classes for an abstract method with the
        // same name.
        let mut current = current_class.parent_class;
        let mut depth = 0u32;
        while let Some(parent_name) = current {