Tamas Cservenak <******@****.***> 1706804704 +0100

        return new Pair<>(first, second);
    }

    /**
     * インスタンスを構築します。
     */
    public Pair() {
    }

    /**
     * インスタンスを構築します。
     *
     * @param first
     *            1番目の値
     * @param second
     *            2番目の値
     */
    public Pair(final T1 first, final T2 second) {
        this.first = first;
        this.second = second;

                // care performance for List that the most frequent pattern
                final Object first = coll instanceof List<?> ? ((List<?>) coll).get(0) : coll.iterator().next();
                if (first instanceof Entity) {
                    data.register(key, coll.stream().map(BeanUtil::copyBeanToNewMap).collect(Collectors.toList()));
                    return;

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

     * The model building request passed to this method must be the same as the one used for the first phase of the
     * model building.
     *
     * @param request The model building request that holds the parameters, must not be {@code null}.
     * @param result The interim result of the first phase of model building, must not be {@code null}.
     * @return The result of the model building, never {@code null}.

        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