}
    }

    private
    fun maybeInit(beanType: Class<*>) {
        val superclass = beanType.superclass
        if (superclass?.classLoader != null) {
            Class.forName(superclass.name, true, superclass.classLoader)
            maybeInit(superclass)
        }
    }

    // TODO: What about the runtime decorations a serialized bean might have had at configuration time?

private
abstract class TopLevelForSubtyping {
    @get:Restricted
    abstract var superClassProp: SuperClass

    @get:Restricted
    abstract var superInterfaceProp: SuperInterface

    @Adding
    abstract fun addSuperClass(superclass: SuperClass)

    @Adding
    abstract fun addSuperInterface(superclass: SuperInterface)

    @Restricted
    abstract fun sub(): Subtype

    @Restricted

        when:
        def m = method.overriddenMethod

        then:
        m == overriddenMethod
        _ * owner.superClass >> superClassMetaData
        _ * owner.interfaces >> []
        1 * superClassMetaData.findDeclaredMethod('method()') >> null
        _ * superClassMetaData.superClass >> ancestorClassMetaData
        _ * superClassMetaData.interfaces >> []

        require(subClass is KaFirSymbol<*>)
        require(superClass is KaFirSymbol<*>)

        if (subClass == superClass) return false
        return isSubClassOf(
            subClass = subClass.firSymbol.fir as FirClass,
            superClass = superClass.firSymbol.fir as FirClass,
            rootModuleSession,

    /**
     * Checks if [this] class has [superClass] listed as its direct superclass.
     *
     * N.B. The class is not considered to be a direct subclass of itself, so `myClass.isDirectSubClassOf(myClass)` is always `false`.
     */
    public fun KaClassOrObjectSymbol.isDirectSubClassOf(superClass: KaClassOrObjectSymbol): Boolean =

        if (superClassName != null) {
            // Assume this is a class and so has implemented all properties and methods somewhere in the superclass hierarchy
            ClassDoc superClass = model.getClassDoc(superClassName);
            classDoc.setSuperClass(superClass);
            superClass.addSubClass(classDoc);
        }

        List<String> interfaceNames = classMetaData.getInterfaceNames();

     *
     * @param subClass the subClass or object symbol.
     * @param superClass the super class symbol.
     * @return [KaSubstitutor] if [subClass] inherits [superClass] and there are no error types in the inheritance path. Returns `null` otherwise.
     */
    public fun createInheritanceTypeSubstitutor(
        subClass: KaClassOrObjectSymbol,
        superClass: KaClassOrObjectSymbol,
    ): KaSubstitutor? = withValidityAssertion {

        return member instanceof JApiClass && !member.superclass.binaryCompatible && !member.superclass.compatibilityChanges.empty
    }

    @Override
    protected Violation checkSuperClassChanges(JApiClass apiClass, CtClass oldClass, CtClass newClass) {
        return acceptOrReject(apiClass.superclass, Violation.notBinaryCompatible(apiClass.superclass))
    }

import com.google.common.annotations.GwtCompatible;

/**
 * A dummy superclass to support GWT serialization of the element type of an {@link
 * ImmutableMultiset}. The GWT supersource for this class contains a field of type {@code E}.
 *
 * <p>For details about this hack, see {@code GwtSerializationDependencies}, which takes the same
 * approach but with a subclass rather than a superclass.
 *

            classes[it.simpleName] = instanceScopedPool.get(it.name)
        }

        classes['OldBase'].superclass = classes['OldSuperInternal']
        classes['NewBase'].superclass = classes['NewSuperInternal']
        classes['OldSub'].superclass = classes['OldBase']
        classes['NewSub'].superclass = classes['NewBase']

        apiClass.compatibilityChanges >> [JApiCompatibilityChange.METHOD_REMOVED_IN_SUPERCLASS]
    }