NoActualClassMemberForExpectedClassImpl(
            firSymbolBuilder.buildSymbol(firDiagnostic.a),
            firDiagnostic.b.map { pair ->
                firSymbolBuilder.buildSymbol(pair.first) to pair.second.mapKeys { (mismatchOrIncompatible, _) ->
                                    mismatchOrIncompatible
                                }.mapValues { (_, collection) -> 

            return expression
        }
        val first = mappingConversionFirst.convertExpression("$expression.first", context)
        val second = mappingConversionSecond.convertExpression("$expression.second", context)
        return "$first to $second"
    }

    override fun convertType(type: KType): KType {
        val first = type.arguments.getOrNull(0)?.type ?: return type

    analysisSession: KtFirAnalysisSession,
) : KtFirBasedScope<FirDefaultStarImportingScope>(firScope, analysisSession.firSymbolBuilder) {

    private val firstWrappedScope = KtFirStarImportingScope(firScope.first, analysisSession)
    private val secondWrappedScope = KtFirStarImportingScope(firScope.second, analysisSession)

    override fun getPackageSymbols(nameFilter: KtScopeNameFilter): Sequence<KtPackageSymbol> = withValidityAssertion {

        }
    }

    override val qualifiers: List<KtClassTypeQualifier.KtUnresolvedClassTypeQualifier>
        get() = withValidityAssertion {
            fe10Type.formatParams.first().split('.').map {
                KtClassTypeQualifier.KtUnresolvedClassTypeQualifier(Name.guessByFirstCharacter(it), emptyList(), token)
            }
        }

    // As it's basically a DAG traversal, we can keep a queue instead of making recursive calls.
    val allFiles = this
    val filesQueueToAnalyze = ArrayDeque(allFiles)
    val collector = InlineFunctionsCollector(allFiles.first().project, reifiedInlineFunctionsOnly = false) { declaration ->
        val containingFile = declaration.containingKtFile
        if (allFiles.add(containingFile)) {
            filesQueueToAnalyze += containingFile
        }

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

    override fun isEqualTo(first: KtType, second: KtType): Boolean {
        require(first is KtFe10Type)
        require(second is KtFe10Type)
        return analysisContext.resolveSession.kotlinTypeCheckerOfOwnerModule.equalTypes(first.fe10Type, second.fe10Type)
    }

    override fun isSubTypeOf(subType: KtType, superType: KtType): Boolean {

) : KtSubtypingComponent(), KtFirAnalysisSessionComponent {
    override fun isEqualTo(first: KtType, second: KtType): Boolean {
        second.assertIsValidAndAccessible()
        check(first is KtFirType)
        check(second is KtFirType)
        return AbstractTypeChecker.equalTypes(
            createTypeCheckerContext(),
            first.coneType,
            second.coneType
        )
    }

        }
    }

    override fun tryRenderAsNonErrorType(): String? = withValidityAssertion {
        when (fe10Type.kind) {
            ErrorTypeKind.UNINFERRED_TYPE_VARIABLE -> fe10Type.formatParams.first()
            else -> null
        }
    }


    override fun asStringForDebugging(): String = withValidityAssertion { fe10Type.asStringForDebugging(analysisContext) }

    override val errorMessage: String

            is ConeCapturedType -> lowerType?.toConstantValueKind() ?: constructor.supertypes!!.first().toConstantValueKind()
            is ConeDefinitelyNotNullType -> original.toConstantValueKind()
            is ConeIntersectionType -> intersectedTypes.first().toConstantValueKind()
            is ConeStubType, is ConeIntegerLiteralType, is ConeTypeVariableType -> null
        }

        is ConeUnresolvedReferenceError -> name
        is ConeUnresolvedSymbolError -> classId.shortClassName
        is ConeUnresolvedTypeQualifierError -> {
            // we take the first qualifier part because only the first one can be imported
            qualifiers.firstOrNull()?.name
        }
    }


/**
 * An actual name by which this callable reference was used.
 */