Method extract_classes_from_statements

src/parser/classes.rs:823–1264

Recursively walk statements and extract class information. This handles classes at the top level as well as classes nested inside namespace declarations.

(
        statements: impl Iterator<Item = &'a Statement<'a>>,
        classes: &mut Vec<ClassInfo>,
        doc_ctx: Option<&DocblockCtx<'a>>,
    )

    /// This handles classes at the top level as well as classes nested
    /// inside namespace declarations.
    pub(crate) fn extract_classes_from_statements<'a>(
        statements: impl Iterator<Item = &'a Statement<'a>>,
        classes: &mut Vec<ClassInfo>,
        doc_ctx: Option<&DocblockCtx<'a>>,
    ) {
        for statement in statements {
            match statement {
                Statement::Class(class) => {
                    // Skip classes whose docblock has `@removed X.Y`
                    // where X.Y <= the target PHP version.
                    if let Some(ctx) = doc_ctx
                        && let Some(ver) = ctx.php_version
                        && is_removed_for_version(class, ctx, ver)
                    {
                        continue;
                    }

                    let class_name = atom(class.name.value);

                    let parent_class = class
                        .extends
                        .as_ref()
                        .and_then(|ext| ext.types.first().map(|ident| atom(ident.value())));

                    let interfaces: Vec<Atom> = class
                        .implements
                        .as_ref()
                        .map(|imp| imp.types.iter().map(|ident| atom(ident.value())).collect())
                        .unwrap_or_default();

                    let doc_info = extract_class_docblock(class, doc_ctx);

                    let ExtractedMembers {
                        methods,
                        properties,
                        constants,
                        used_traits,
                        trait_precedences,
                        trait_aliases,
                        inline_use_generics,
                    } = Self::extract_class_like_members(
                        class.members.iter(),
                        doc_ctx,
                        &doc_info.template_params,
                    );

                    let mut use_generics: Vec<(Atom, Vec<PhpType>)> = doc_info.use_generics;
                    use_generics.extend(inline_use_generics);

                    let keyword_offset = class.class.span.start.offset;
                    let start_offset = class.left_brace.start.offset;
                    let end_offset = class.right_brace.end.offset;

                    let content = doc_ctx.map(|c| c.content).unwrap_or("");
                    let custom_collection = extract_custom_collection(
                        &class.attribute_lists,
                        &use_generics,
                        &methods,