## Kotlin Multiplatform capabilities

Support for multiplatform programming is one of Kotlin’s key benefits. It reduces time spent writing and maintaining the same code for [different platforms](https://kotlinlang.org/docs/reference/mpp-supported-platforms.html) while retaining the flexibility and benefits of native programming.

            val resolvedList = renderAnnotation(annotationList.single { it.classId == classId })
            testServices.assertions.assertEquals(resolvedList, rawList) {
                "Result before and after resolve are different"
            }

            resolvedList
        }

        testServices.assertions.assertEqualsToTestDataFileSibling(actual)
    }

    private object Directives : SimpleDirectivesContainer() {

 * expanded type from a library vs. from a source module. (Abbreviated types from libraries and from sources aren't necessarily constructed
 * in the same way.)
 *
 * This test is different from [AbstractTypeByDeclarationReturnTypeTest] because we want to generate tests for extension-site modules with
 * [TestModuleKind.Source][org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind.Source] and

     * Keys for this map is from the set [partiallyAppliedSymbol].signature.typeParameters.
     * In case of resolution or inference error could return empty map.
     */
    public abstract val typeArgumentsMapping: Map<KaTypeParameterSymbol, KaType>
}

import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.psi.psiUtil.*
import org.jetbrains.kotlin.resolve.BindingContext
import org.jetbrains.kotlin.resolve.calls.components.isVararg
import org.jetbrains.kotlin.resolve.calls.inference.returnTypeOrNothing
import org.jetbrains.kotlin.resolve.calls.smartcasts.MultipleSmartCasts
import org.jetbrains.kotlin.resolve.calls.smartcasts.SingleSmartCast
import org.jetbrains.kotlin.resolve.calls.util.getParameterForArgument

import org.jetbrains.kotlin.name.StandardClassIds
import org.jetbrains.kotlin.renderer.DescriptorRenderer
import org.jetbrains.kotlin.renderer.render
import org.jetbrains.kotlin.resolve.calls.inference.CapturedType
import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass
import org.jetbrains.kotlin.types.*
import org.jetbrains.kotlin.types.checker.NewCapturedType

        val expectedExpanded = type.expandedSymbol

        // if the underlying classes are equal, we consider the check successful
        // despite the possibility of different type bounds
        if (
            receiverExpanded != null &&
            receiverExpanded == expectedExpanded
        ) {
            return true
        }

     */
    public val hasEscapingJumps: Boolean,

    /**
     * `true` if there are jumps of different kinds (e.g., there is both a `break` and a `return`).
     */
    public val hasMultipleJumpKinds: Boolean,

    /**
     * `true` if two or more jumps have different next-executed instructions.

import org.jetbrains.kotlin.analysis.api.types.KaTypeNullability
import org.jetbrains.kotlin.analysis.api.types.KaTypeProjection
import org.jetbrains.kotlin.analysis.api.types.KaUsualClassType
import org.jetbrains.kotlin.resolve.calls.inference.CapturedType

internal class KaFe10CapturedType(
    override val fe10Type: CapturedType,
    override val analysisContext: Fe10AnalysisContext
) : KaCapturedType(), KaFe10Type {

 * constructor and then add it to [destination]. Unmerged elements are added to [destination] using [finish].
 *
 * The purpose of [SublistMerger] is to merge multiple different types of elements from a single origin list without the need for
 * intermediate list management and [partitionIsInstance] boilerplate.
 */
public class SublistMerger<A : Any>(
    initialElements: List<A>,