err := unix.Uname(&v)
	if err != nil {
		telemetry.Inc(fmt.Sprintf("go/platform/host/%s/version:unknown-uname-error", runtime.GOOS))
		return
	}
	major, minor, ok := majorMinor(convert(v.Release[:]))
	if runtime.GOOS == "aix" {
		major, minor, ok = convert(v.Version[:]), convert(v.Release[:]), true
	}
	if !ok {
		telemetry.Inc(fmt.Sprintf("go/platform/host/%s/version:unknown-bad-format", runtime.GOOS))
		return
	}

public interface KaPossibleMultiplatformSymbol : KaSymbol {
    /**
     * Returns true if the declaration is a platform-specific implementation in a multiplatform project.
     */
    public val isActual: Boolean

    /**
     * Returns true if the declaration is platform-specific declaration in a multiplatform project. An implementation
     * in platform modules is expected. Note, that in the following example:
     * ```
     * expect class A {

            buildKtModuleProvider {
                platform = nativePlatform
                val kLib = addModule(
                    buildKtLibraryModule {
                        val compiledKLibRoot = compileToNativeKLib(testDataPath("resolveAgainstNativeKLib/klibSrc"))
                        addBinaryRoot(compiledKLibRoot)
                        platform = nativePlatform
                        libraryName = "klib"

            buildKtModuleProvider {
                platform = targetPlatform
                val stdlib = addModule(
                    buildKtLibraryModule {
                        addBinaryRoot(platformStdlibPath)
                        addBinaryRoots(additionalStdlibRoots)
                        platform = targetPlatform
                        libraryName = "stdlib"
                    }

import org.jetbrains.kotlin.analysis.project.structure.KtNotUnderContentRootModule
import org.jetbrains.kotlin.analysis.project.structure.computeTransitiveDependsOnDependencies
import org.jetbrains.kotlin.platform.TargetPlatform
import org.jetbrains.kotlin.platform.jvm.JvmPlatforms

internal class KtNotUnderContentRootModuleImpl(
    override val name: String,
    override val directRegularDependencies: List<KtModule> = emptyList(),

 */

package org.jetbrains.kotlin.analysis.api.standalone.fir.test.cases.session.builder

import org.jetbrains.kotlin.platform.CommonPlatforms
import org.jetbrains.kotlin.platform.js.JsPlatforms
import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
import org.jetbrains.kotlin.utils.PathUtil
import org.junit.Test
import java.nio.file.Paths

## Platform architecture

Gradle is arranged into several coarse-grained components called "platforms".
Each platform provides support for some kind of automation, such as building JVM software or building Gradle plugins.
Most platforms typically build on the features of other platforms.

 */

package org.jetbrains.kotlin.analysis.api.platform.modification

import com.intellij.openapi.project.Project
import org.jetbrains.annotations.TestOnly
import org.jetbrains.kotlin.analysis.api.platform.KotlinPlatformComponent
import org.jetbrains.kotlin.analysis.project.structure.KtModule

/**

plugins {
    id("gradlebuild.kotlin-shared-runtime")
}

description = "Provides Kotlin DSL code that is shared between build-logic and runtime"

dependencies {
    compileOnly(platform("gradlebuild:build-platform"))
    compileOnly(kotlin("stdlib"))
    compileOnly("org.ow2.asm:asm-tree")
    compileOnly("com.google.code.findbugs:jsr305")

import org.jetbrains.kotlin.analysis.api.platform.declarations.KotlinAnnotationsResolverFactory
import org.jetbrains.kotlin.analysis.api.platform.declarations.KotlinDeclarationProviderFactory
import org.jetbrains.kotlin.analysis.api.platform.declarations.KotlinDeclarationProviderMerger
import org.jetbrains.kotlin.analysis.api.platform.modification.KotlinGlobalModificationService