writeClassEnd()
    }

    private fun writeGenericArguments(sw: JvmSignatureWriter, type: PossiblyInnerType, mode: TypeMappingMode) {
        val classifier = type.classifierDescriptor
        val defaultType = classifier.defaultType
        val parameters = classifier.declaredTypeParameters
        val arguments = type.arguments

        }
    }

    private fun Fe10AnalysisContext.renderTypeSegment(typeSegment: PossiblyInnerType, printer: PrettyPrinter) {
        with(printer) {
            val classifier = typeSegment.classifierDescriptor

            append(classifier.maybeLocalClassId.asString())

            val arguments = typeSegment.arguments
            printCollectionIfNotEmpty(arguments, separator = ", ", prefix = "<", postfix = ">") {

            } + nullableSuffix
        }
    }
    print(typeConversion(type))
}

val KType.simpleName: String
    get() = (classifier as KClass<*>).simpleName!!

val KType.qualifiedName: String

        // supertypes.
        delegate.processClassifiersByNameWithSubstitution(name) { classifier, substitutor ->
            if (classifier is FirRegularClassSymbol && classifier.fir.isDeclared()) {
                processor(classifier, substitutor)
            }
        }
    }

    processClassifiersByNameWithSubstitution(name) { classifier, substitutor ->
        val firDeclaration = classifier.fir
        if (firDeclaration is FirMemberDeclaration && firDeclaration.isInner) {
            processor(classifier, substitutor)
        }
    }

        val classifiersToSkip = expression.parents.takeWhile { it != ktTypeElementFromFirType }.count()
        var classifier: FirClassLikeSymbol<*>? = fir.type.toRegularClassSymbol(session)
        repeat(classifiersToSkip) {
            classifier = classifier?.getContainingClassSymbol(session)
        }

        val firClassSymbol = classifier
            ?: return listOfNotNull(getPackageSymbolFor(expression, symbolBuilder, forQualifiedType = true))

            }

}

internal object FirToKtConversionCreator {
    fun createConversion(type: KType): HLParameterConversion {
        val nullable = type.isMarkedNullable
        val kClass = type.classifier as KClass<*>
        return tryMapAllowedType(kClass)
            ?: tryMapPsiElementType(kClass)
            ?: tryMapFirTypeToKtType(kClass, nullable)
            ?: tryMapPlatformType(type, kClass)

                    // A callable declaration from dynamic scope has no containing declaration as it comes from a dynamic type
                    // which is not based on a specific classifier
                    return null
                }
            }

            is KtClassLikeSymbol -> {
                val outerClassId = symbol.classIdIfNonLocal?.outerClassId

    override val expectedCount: Int,
    override val classifier: KtClassLikeSymbol,
    firDiagnostic: KtPsiDiagnostic,
    token: KtLifetimeToken,
) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.WrongNumberOfTypeArguments

internal class NoTypeArgumentsOnRhsImpl(
    override val expectedCount: Int,
    override val classifier: KtClassLikeSymbol,
    firDiagnostic: KtPsiDiagnostic,

        val owner = descriptor.owner

        if (descriptor is IrBasedReceiverParameterDescriptor && owner is IrValueParameter) {
            val receiverClass = (owner.type as? IrSimpleType)?.classifier as? IrClassSymbol
            val receiverClassId = receiverClass?.owner?.classId

            if (receiverClassId != null) {
                if (owner.index >= 0) {