Method extract_class_like_members

src/parser/classes.rs:1747–2516

Extract methods, properties, constants, and used trait names from class-like members. This is shared between `Statement::Class`, `Statement::Interface`, and `Statement::Trait` since all use the same `ClassLikeMember` representation. When `doc_ctx` is provided, PHPDoc `@return` and `@var` tags are used to refine (or supply) type information for methods and properties.

(
        members: impl Iterator<Item = &'a ClassLikeMember<'a>>,
        doc_ctx: Option<&DocblockCtx<'a>>,
        class_template_params: &[Atom],
    )

    /// When `doc_ctx` is provided, PHPDoc `@return` and `@var` tags are used
    /// to refine (or supply) type information for methods and properties.
    pub(crate) fn extract_class_like_members<'a>(
        members: impl Iterator<Item = &'a ClassLikeMember<'a>>,
        doc_ctx: Option<&DocblockCtx<'a>>,
        class_template_params: &[Atom],
    ) -> ExtractedMembers {
        /// Resolve a short class name to its FQN using the file's use-map
        /// and namespace from [`DocblockCtx`].  When no context is
        /// available the name is returned as-is.
        fn resolve_name_via_ctx(name: &str, doc_ctx: Option<&DocblockCtx<'_>>) -> String {
            // Already fully-qualified — strip the leading `\`.
            if let Some(stripped) = name.strip_prefix('\\') {
                return stripped.to_string();
            }
            let Some(ctx) = doc_ctx else {
                return name.to_string();
            };
            // Check use-map (handles both unqualified and qualified names).
            if let Some(pos) = name.find('\\') {
                let first = &name[..pos];
                let rest = &name[pos..];
                if let Some(fqn) = ctx.use_map.get(first) {
                    return format!("{fqn}{rest}");
                }
            } else if let Some(fqn) = ctx.use_map.get(name) {
                return fqn.clone();
            }
            // Prepend current namespace if available.
            if let Some(ref ns) = ctx.namespace {
                format!("{ns}\\{name}")
            } else {
                name.to_string()
            }
        }

        let mut methods = Vec::new();
        let mut properties = Vec::new();
        let mut constants = Vec::new();
        let mut used_traits: Vec<Atom> = Vec::new();
        let mut trait_precedences = Vec::new();
        let mut trait_aliases = Vec::new();
        let mut inline_use_generics: Vec<(Atom, Vec<PhpType>)> = Vec::new();
        let mut constructor_body: Option<&MethodBody<'_>> = None;

        for member in members {
            match member {
                ClassLikeMember::Method(method) => {
                    // Skip methods whose #[PhpStormStubsElementAvailable]
                    // range excludes the target PHP version.
                    if let Some(ctx) = doc_ctx
                        && let Some(ver) = ctx.php_version
                        && !is_available_for_version(&method.attribute_lists, ctx, ver)
                    {
                        continue;
                    }

                    // Skip methods whose docblock has `@removed X.Y`
                    // where X.Y <= the target PHP version.
                    if let Some(ctx) = doc_ctx