struct category_t {
    const char *name;                 // 分类名，例如 "Debug"
    classref_t cls;                   // 目标类引用，加载时会 remapClass()
    WrappedPtr<method_list_t> instanceMethods;
    WrappedPtr<method_list_t> classMethods;
    protocol_list_t *protocols;
    property_list_t *instanceProperties;
    property_list_t *_classProperties; // 新 ABI 中可选存在

    method_list_t *methodsForMeta(bool isMeta) const {
        return isMeta ? classMethods : instanceMethods;
    }

    protocol_list_t *protocolsForMeta(bool isMeta) const {
        return isMeta ? nullptr : protocols;
    }
};

if (cat->instanceMethods || cat->protocols || cat->instanceProperties) {
    if (cls->isRealized()) {
        attachCategories(cls, &lc, 1, cls, ATTACH_EXISTING);
    } else {
        // 目标类还没有实现化：先按类指针作为 key 暂存。
        unattachedCategories.addForClass(lc, cls);
    }
}

if (cat->classMethods || cat->protocols || hasClassProperties) {
    if (cls->ISA()->isRealized()) {
        attachCategories(cls->ISA(), &lc, 1, cls,
                         ATTACH_EXISTING | ATTACH_METACLASS);
    } else {
        // 元类路径需要用元类重新签名分类指针。
        unattachedCategories.addForClass(lc.reSignedForMetaclass(cls),
                                         cls->ISA());
    }
}

static void methodizeClass(Class cls, Class previously)
{
    // 先准备类自身 method_list_t，root metaclass 还会补 initialize。
    prepareMethodLists(...);

    // 类重定位时，previously key 下可能也有暂存分类。
    if (previously) {
        unattachedCategories.attachToClass(cls, previously,
            isMeta ? ATTACH_METACLASS : ATTACH_CLASS_AND_METACLASS);
    }

    // 普通路径：取出以 cls 为 key 的暂存分类并附加。
    unattachedCategories.attachToClass(cls, cls,
        isMeta ? ATTACH_METACLASS : ATTACH_CLASS);
}

for (uint32_t i = 0; i < cats_count; i++) {
    method_list_t *mlist =
        entry.getCategory(catsListKey)->methodsForMeta(isMeta);
    property_list_t *proplist =
        entry.getCategory(catsListKey)->propertiesForMeta(isMeta, entry.hi);
    protocol_list_t *protolist =
        entry.getCategory(catsListKey)->protocolsForMeta(isMeta);

    // 根据 dyld 是否已经预优化分类，放到不同缓冲区。
    Lists *lists = isPreattached ? &preattachedLists : &normalLists;
    lists->methods.add(mlist);
    lists->properties.add(proplist);
    lists->protocols.add(protolist);
}

if (lists->methods.count > 0) {
    prepareMethodLists(cls, lists->methods.begin(), lists->methods.count,
                       NO, fromBundle, __func__);
    rwe->methods.attachLists(lists->methods.begin(),
                             lists->methods.count, isPreattached, "methods");

    if (flags & ATTACH_EXISTING) {
        // 已有类可能缓存过旧 IMP，需要擦掉受影响 cache。
        flushCaches(cls, __func__, [](Class c) {
            return !c->cache.isConstantOptimizedCache();
        });
    }
}

rwe->properties.attachLists(...);
rwe->protocols.attachLists(...);

if (oldList) array->lists[addedCount] = oldList;
for (unsigned i = 0; i < addedCount; i++)
    array->lists[i] = addedLists[i];       // 0/1 个旧列表时，新增列表放前面

for (int i = oldCount - 1; i >= 0; i--)
    newArray->lists[i + addedCount] = array->lists[i];
for (unsigned i = 0; i < addedCount; i++)
    newArray->lists[i] = addedLists[i];    // 多个旧列表时仍然前插

for (category_t *cat : nonLazyCategoryList) {
    Class cls = remapClass(cat->cls);
    realizeClassWithoutSwift(cls, nil);    // 触发 methodizeClass 和分类附加
    add_category_to_loadable_list(cat);    // 只把实现了 +load 的分类入队
}

do {
    while (loadable_classes_used > 0) {
        call_class_loads();                // 类 +load：父类优先
    }
    more_categories = call_category_loads(); // 分类 +load：父类已连接后
} while (loadable_classes_used > 0 || more_categories);