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,
        )
    }

 * 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 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) }

        val declaration = testServices.expressionMarkerProvider.getSelectedElementOrElementAtCaretOfTypeByDirective(
            ktFile, testServices.moduleStructure.modules.first(),
            KtDeclaration::class
        ) as KtDeclaration
        val symbol = declaration.getSymbol()
        return SymbolsData(listOf(symbol))
    }

    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)
        }

 * [FirDeclarationGenerationExtension][org.jetbrains.kotlin.fir.extensions.FirDeclarationGenerationExtension]s.
 *
 * [DeclarationsInPackageProvider] first tries the [FirSymbolNamesProvider] of the analysis session's underlying FIR session, because it
 * provides symbol names from binary libraries in Standalone mode, which the Standalone declaration provider does not contain (to avoid

            // currently only testing the IDE mode and (2) the test results between different modes should not differ for session
            // invalidation in the first place.
            testPrefix = resultFileSuffix,
        )
    }

    private fun checkSessionValidityBeforeModification(
        sessions: List<SESSION>,
        testServices: TestServices,
    ) {

        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

 * [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)