override val token: KaLifetimeToken
        get() = analysisSession.token

    override fun isEqualTo(first: KaType, second: KaType, errorTypePolicy: KaSubtypingErrorTypePolicy): Boolean {
        require(first is KaFe10Type)
        require(second is KaFe10Type)
        return getTypeCheckerFor(errorTypePolicy).equalTypes(first.fe10Type, second.fe10Type)
    }

    builder: KaSymbolByFirBuilder,
) : AbstractKaFirSubstitutor<ChainedSubstitutor>(substitutor, builder), KaChainedSubstitutor {
    override val first
        get(): KaSubstitutor {
            return builder.typeBuilder.buildSubstitutor(substitutor.first)
        }

    override val second
        get(): KaSubstitutor {
            return builder.typeBuilder.buildSubstitutor(substitutor.second)
        }

    override fun isEqualTo(first: KaType, second: KaType, errorTypePolicy: KaSubtypingErrorTypePolicy): Boolean {
        second.assertIsValidAndAccessible()
        check(first is KaFirType)
        check(second is KaFirType)
        return AbstractTypeChecker.equalTypes(
            createTypeCheckerContext(errorTypePolicy),
            first.coneType,
            second.coneType,
        )
    }

        get() = withValidityAssertion {
            fe10Type.formatParams.first().split('.').map {
                KaClassTypeQualifier.KaUnresolvedClassTypeQualifier(Name.guessByFirstCharacter(it), emptyList(), token)
            }
        }

    @KaAnalysisNonPublicApi
    override val presentableText: String?
        get() = withValidityAssertion { fe10Type.formatParams.first() }

    @KaAnalysisNonPublicApi

 * This is an implementation detail,
 * and Analysis API clients should not depend on the fact if some [KaSubstitutor] is [KaChainedSubstitutor] or not.
 */
@KaAnalysisApiInternals
interface KaChainedSubstitutor : KaSubstitutor {
    val first: KaSubstitutor
    val second: KaSubstitutor

    override fun getSeparatorBetweenMembers(analysisSession: KaSession, first: KaDeclarationSymbol, second: KaDeclarationSymbol): String {
        return when {
            first is KaEnumEntrySymbol && second is KaEnumEntrySymbol -> ",\n"
            first is KaEnumEntrySymbol && second !is KaEnumEntrySymbol -> ";\n\n"
            else -> "\n\n"
        }
    }
}

            override fun visitElement(element: PsiElement) {
                if (element !is KtLightElement<*, *>) return
                // NB: intentionally visit members first so that `self` can be found first if matched
                if (element is PsiClass) {
                    element.fields.forEach { it.accept(this) }
                    element.methods.forEach { it.accept(this) }

        if (ktReferences.isEmpty()) {
            testServices.assertions.fail { "No references at caret found" }
        }

        val element = ktReferences.first().element
        val resolvedTo = analyseForTest(element) {
            val symbols = ktReferences.flatMap { it.resolveToSymbols() }
            val psiElements = symbols.mapNotNull { psiForTest(it, element.project) }

 * [Kotlin Multiplatform Mobile](https://kotlinlang.org/lp/mobile/) for sharing code between Android and iOS
 * [Getting Started with Kotlin Multiplatform Mobile Guide](https://kotlinlang.org/docs/mobile/create-first-app.html)
 * [Kotlin Multiplatform Benefits](https://kotlinlang.org/docs/reference/multiplatform.html)
 * [Share code on all platforms](https://kotlinlang.org/docs/reference/mpp-share-on-platforms.html#share-code-on-all-platforms)

    @KaAnalysisNonPublicApi
    override val presentableText: String?
        get() = withValidityAssertion {
            when (fe10Type.kind) {
                ErrorTypeKind.UNINFERRED_TYPE_VARIABLE -> fe10Type.formatParams.first()
                else -> null
            }
        }

    @KaAnalysisNonPublicApi
    override val errorMessage: String
        get() = withValidityAssertion { fe10Type.debugMessage }