Skip to content

Multiplatform Gradle DSL リファレンス ​

Kotlin Multiplatform Gradle プラグインは、Kotlin Multiplatform プロジェクトを作成するためのツールです。 ここでは、その内容のリファレンスを提供します。Kotlin Multiplatform プロジェクトの Gradle ビルドスクリプトを記述する際の備忘録として活用してください。Kotlin Multiplatform プロジェクトの概念、作成および設定方法については、リンク先で学習できます。

ID とバージョン ​

Kotlin Multiplatform Gradle プラグインの完全修飾名は org.jetbrains.kotlin.multiplatform です。 Kotlin Gradle DSL を使用する場合、kotlin("multiplatform") でプラグインを適用できます。 プラグインのバージョンは Kotlin のリリースバージョンと一致します。最新バージョンは 2.4.21 です。

kotlin
plugins {
    kotlin("multiplatform") version "2.4.21"
}
groovy
plugins {
    id 'org.jetbrains.kotlin.multiplatform' version '2.4.21'
}

トップレベルブロック ​

kotlin {} は、Gradle ビルドスクリプトにおけるマルチプラットフォームプロジェクト設定のトップレベルブロックです。 kotlin {} 内には、以下のブロックを記述できます。

ブロック説明
<targetName>プロジェクトの特定のターゲットを宣言します。利用可能なターゲットの名前は ターゲット セクションにリストされています。
targetsプロジェクトのすべてのターゲットをリストします。
sourceSetsプロジェクトの定義済み ソースセット の設定、およびカスタムソースセットの宣言を行います。
compilerOptionsすべてのターゲットおよび共有ソースセットのデフォルトとして使用される、共通の拡張レベル コンパイラオプション を指定します。
dependencies共通の依存関係 を設定します。(実験的機能)

ターゲット ​

ターゲット(target) は、サポートされているプラットフォームのいずれかに向けたソフトウェアのコンパイル、テスト、およびパッケージ化を担当するビルドの一部です。Kotlin は各プラットフォーム向けのターゲットを提供しており、特定のターゲット向けにコードをコンパイルするよう Kotlin に指示できます。ターゲットの設定についての詳細をご覧ください。

各ターゲットは、1 つ以上の コンパイル を持つことができます。テスト用および製品用のデフォルトのコンパイルに加えて、カスタムコンパイルを作成 することもできます。

マルチプラットフォームプロジェクトのターゲットは、kotlin {} 内の対応するブロック(例:jvm、android、iosArm64)で記述されます。 利用可能なターゲットの完全なリストは以下の通りです。

ターゲットプラットフォームターゲットコメント
Kotlin/JVMjvm
Kotlin/WasmwasmJsプロジェクトを JavaScript ランタイムで実行する予定がある場合に使用します。
wasmWasiWASI システムインターフェースのサポートが必要な場合に使用します。
Kotlin/JSjs

実行環境を選択してください:

  • ブラウザで実行されるアプリケーションの場合は browser {}。
  • Node.js で実行されるアプリケーションの場合は nodejs {}。

詳細は Kotlin/JS プロジェクトの設定 をご覧ください。

Kotlin/Native

macOS、Linux、および Windows ホストで現在サポートされているターゲットについては、Kotlin/Native ターゲットのサポート をご覧ください。

Android アプリケーションおよびライブラリandroid

Android Gradle プラグイン(com.android.application または com.android.kotlin.multiplatform.library)を手動で適用してください。

Gradle サブプロジェクトごとに作成できる Android ターゲットは 1 つだけです。

現在のホストでサポートされていないターゲットはビルド中に無視されるため、パブリッシュ(公開)されません。

groovy
kotlin {
    jvm()
    iosArm64()
    macosArm64()
    js().browser()
}

ターゲットの設定には、以下の 2 つのパートを含めることができます。

各ターゲットは、1 つ以上の コンパイル を持つことができます。

共通ターゲット設定 ​

どのターゲットブロック内でも、以下の宣言を使用できます。

名前説明
platformTypeこのターゲットの Kotlin プラットフォーム。利用可能な値:jvm, androidJvm, js, wasm, native, common。
artifactsTaskNameこのターゲットの成果物(artifact)をビルドするタスクの名前。
componentsGradle パブリケーションの設定に使用されるコンポーネント。
compilerOptionsターゲットに使用される コンパイラオプション。この宣言は、トップレベル で設定された compilerOptions {} を上書きします。

Web ターゲット ​

js {} ブロックは Kotlin/JS ターゲットの設定を記述し、wasmJs {} ブロックは JavaScript と相互運用可能な Kotlin/Wasm ターゲットの設定を記述します。ターゲットの実行環境に応じて、以下の 2 つのブロックのいずれかを含めることができます。

名前説明
browserブラウザターゲットの設定。
nodejsNode.js ターゲットの設定。

Kotlin/JS プロジェクトの設定 についての詳細をご覧ください。

独立した wasmWasi {} ブロックは、WASI システムインターフェースをサポートする Kotlin/Wasm ターゲットの設定を記述します。 これは nodejs および wasmtime 実行環境をサポートしています:

kotlin
kotlin {
    wasmWasi {
        nodejs()
        wasmtime()
        binaries.executable()
    }
}

すべての Web ターゲット(js、wasmJs、wasmWasi)は、binaries.executable() 呼び出しもサポートしています。これは、実行可能ファイルを生成するように Kotlin コンパイラに明示的に指示するものです。詳細については、Kotlin/JS ドキュメントの 実行環境 を参照してください。

Browser ​

browser {} には、以下の設定ブロックを含めることができます。

名前説明
testRunsテスト実行の設定。
runTaskプロジェクト実行の設定。
webpackTaskWebpack によるプロジェクトのバンドル設定。
distribution出力ファイルへのパス。
kotlin
kotlin {
    js().browser {
        webpackTask { /* ... */ }
        testRuns { /* ... */ }
        distribution {
            directory = File("$projectDir/customdir/")
        }
    }
}

Node.js ​

nodejs {} には、テストおよび実行タスクの設定を含めることができます。

名前説明
testRunsテスト実行の設定。
runTaskプロジェクト実行の設定。
kotlin
kotlin {
    js().nodejs {
        runTask { /* ... */ }
        testRuns { /* ... */ }
    }
}

Native ターゲット ​

Native ターゲットでは、以下の特定のブロックが利用可能です。

名前説明
binaries生成する バイナリ の設定。
cinteropsC ライブラリとのインターオペラビリティ(相互運用) の設定。

バイナリ ​

以下の種類のバイナリがあります。

名前説明
executable製品の実行可能ファイル。
testテストの実行可能ファイル。
sharedLib共有ライブラリ。
staticLib静的ライブラリ。
frameworkObjective-C フレームワーク。
kotlin
kotlin {
    linuxX64 { // 代わりに自身のターゲットを使用してください。
        binaries {
            executable {
                // バイナリの設定。
            }
        }
    }
}

バイナリ設定には、以下のパラメータが利用可能です。

名前説明
compilationバイナリがビルドされる元のコンパイル。デフォルトでは、test バイナリは test コンパイルに基づき、その他のバイナリは main コンパイルに基づきます。
linkerOptsバイナリのビルド中にシステムリンカーに渡されるオプション。
baseName出力ファイルのカスタムベース名。最終的なファイル名は、このベース名にシステム依存のプレフィックスとポスフィックスを追加して形成されます。
entryPoint実行可能バイナリのエントリポイント関数。デフォルトではルートパッケージの main() です。
outputFile出力ファイルへのアクセス。
linkTaskリンクタスクへのアクセス。
runTask実行可能バイナリの実行タスクへのアクセス。linuxX64、macosArm64、mingwX64 以外のターゲットの場合、値は null です。
isStaticObjective-C フレームワーク用. 動的ライブラリの代わりに静的ライブラリを含めます。
disableNativeCache

コンパイルキャッシュを無効にします。コンパイル時間が増加するため、例外的な場合にのみ使用してください。

キャッシュを無効にする Kotlin の version と reason(理由)を含める必要があります。オプションで、バグトラッカーの issue(課題)への URL を指定できます。

kotlin
binaries {
    executable("my_executable", listOf(RELEASE)) {
        // test コンパイルをベースにバイナリをビルドする。
        compilation = compilations["test"]

        // リンカー用のカスタムコマンドラインオプション。
        linkerOpts = mutableListOf("-L/lib/search/path", "-L/another/search/path", "-lmylib")

        // 出力ファイルのベース名。
        baseName = "foo"

        // カスタムエントリポイント関数。
        entryPoint = "org.example.main"

        // 出力ファイルへのアクセス。
        println("Executable path: ${outputFile.absolutePath}")

        // リンクタスクへのアクセス。
        linkTask.dependsOn(additionalPreprocessingTask)

        // 実行タスクへのアクセス。
        // ホストプラットフォーム以外の場合、runTask は null になることに注意。
        runTask?.dependsOn(prepareForRun)
    }

    framework("my_framework" listOf(RELEASE)) {
        // フレームワークに動的ライブラリの代わりに静的ライブラリを含める。
        isStatic = true

        // このバイナリのコンパイルキャッシュを無効にする
        disableNativeCache(
            version = DisableCacheInKotlinVersion.2_3_0,
            reason = "Cache bug",
            issue = URI("https://youtrack.com/YY-1111")
        )
    }
}
groovy
binaries {
    executable('my_executable', [RELEASE]) {
        // test コンパイルをベースにバイナリをビルドする。
        compilation = compilations.test

        // リンカー用のカスタムコマンドラインオプション。
        linkerOpts = ['-L/lib/search/path', '-L/another/search/path', '-lmylib']

        // 出力ファイルのベース名。
        baseName = 'foo'

        // カスタムエントリポイント関数。
        entryPoint = 'org.example.main'

        // 出力ファイルへのアクセス。
        println("Executable path: ${outputFile.absolutePath}")

        // リンクタスクへのアクセス。
        linkTask.dependsOn(additionalPreprocessingTask)

        // 実行タスクへのアクセス。
        // ホストプラットフォーム以外の場合、runTask は null になることに注意。
        runTask?.dependsOn(prepareForRun)
    }

    framework('my_framework' [RELEASE]) {
        // フレームワークに動的ライブラリの代わりに静的ライブラリを含める。
        isStatic = true

        // このバイナリのコンパイルキャッシュを無効にする
        disableNativeCache(
            version = DisableCacheInKotlinVersion .2_3_0,
            reason = 'Cache bug',
            issue = URI('https://youtrack.com/YY-1111')
        )
    }
}

Native バイナリのビルド についての詳細をご覧ください。

Cinterops ​

cinterops は、Native ライブラリとのインターオペラビリティに関する記述のコレクションです。 ライブラリとのインターオペラビリティを提供するには、cinterops にエントリを追加し、そのパラメータを定義します。

名前説明
definitionFileNative API を記述した .def ファイル。
packageName生成される Kotlin API のパッケージプレフィックス。
compilerOptscinterop ツールによってコンパイラに渡されるオプション。
includeDirsヘッダーを検索するディレクトリ。
headerバインディングに含めるヘッダー。
headersバインディングに含めるヘッダーのリスト。
kotlin
kotlin {
    linuxX64 { // 必要なターゲットに置き換えてください。
        compilations.getByName("main") {
            val myInterop by cinterops.creating {
                // Native API を記述する定義ファイル。
                // デフォルトのパスは src/nativeInterop/cinterop/<interop-name>.def です。
                definitionFile.set(project.file("def-file.def"))

                // 生成された Kotlin API を配置するパッケージ。
                packageName("org.sample")

                // cinterop ツールによってコンパイラに渡されるオプション。
                compilerOpts("-Ipath/to/headers")

                // ヘッダー検索用のディレクトリ(コンパイラオプションの -I<path> と同等)。
                includeDirs.allHeaders("path1", "path2")

                // includeDirs.allHeaders のショートカット。
                includeDirs("include/directory", "another/directory")

                // バインディングに含めるヘッダーファイル。
                header("path/to/header.h")
                headers("path/to/header1.h", "path/to/header2.h")
            }

            val anotherInterop by cinterops.creating { /* ... */ }
        }
    }
}
groovy
kotlin {
    linuxX64 { // 必要なターゲットに置き換えてください。
        compilations.main {
            cinterops {
                myInterop {
                    // Native API を記述する定義ファイル。
                    // デフォルトのパスは src/nativeInterop/cinterop/<interop-name>.def です。
                    definitionFile = project.file("def-file.def")

                    // 生成された Kotlin API を配置するパッケージ。
                    packageName 'org.sample'

                    // cinterop ツールによってコンパイラに渡されるオプション。
                    compilerOpts '-Ipath/to/headers'

                    // ヘッダー検索用のディレクトリ(コンパイラオプションの -I<path> と同等)。
                    includeDirs.allHeaders("path1", "path2")

                    // includeDirs.allHeaders のショートカット。
                    includeDirs("include/directory", "another/directory")

                    // バインディングに含めるヘッダーファイル。
                    header("path/to/header.h")
                    headers("path/to/header1.h", "path/to/header2.h")
                }

                anotherInterop { /* ... */ }
            }
        }
    }
}

cinterop のその他のプロパティについては、定義ファイル(Definition file) を参照してください。

Android ターゲット ​

Kotlin Multiplatform Gradle プラグインには、Android ターゲットの ビルドバリアント(build variants) を設定するのに役立つ特定の関数があります。

名前説明
publishLibraryVariants()パブリッシュするビルドバリアントを指定します。Android ライブラリのパブリッシュ についての詳細をご覧ください。
kotlin
kotlin {
    android {
        publishLibraryVariants("release")
    }
}

Android 向けのコンパイル についての詳細をご覧ください。

kotlin {} ブロック内の android 設定は、Android プロジェクトのビルド設定を置き換えるものではありません。 Android プロジェクトのビルドスクリプトの作成については、Android 開発者ドキュメント をご覧ください。

ソースセット ​

sourceSets {} ブロックはプロジェクトのソースセットを記述します。ソースセットには、リソースや依存関係とともに、一緒にコンパイルされる Kotlin ソースファイルが含まれます。

マルチプラットフォームプロジェクトには、そのターゲットのための 定義済み ソースセットが含まれています。また、開発者は必要に応じて カスタム ソースセットを作成することもできます。

定義済みソースセット ​

定義済みソースセットは、マルチプラットフォームプロジェクトの作成時に自動的に設定されます。 利用可能な定義済みソースセットは以下の通りです。

名前説明
commonMainすべてのプラットフォーム間で共有されるコードとリソース。すべてのマルチプラットフォームプロジェクトで利用可能です。プロジェクトのすべてのメイン コンパイル で使用されます。
commonTestすべてのプラットフォーム間で共有されるテストコードとリソース。すべてのマルチプラットフォームプロジェクトで利用可能です。プロジェクトのすべてのテストコンパイルで使用されます。
<targetName><compilationName>コンパイルのためのターゲット固有のソース。<targetName> は定義済みターゲットの名前、<compilationName> はこのターゲットのコンパイルの名前です。例:jsTest、jvmMain。
kotlin
kotlin {
    //...
    sourceSets {
        commonMain { /* ... */ }
    }
}
groovy
kotlin {
    //...
    sourceSets { 
        commonMain { /* ... */ }
    }
}

ソースセット についての詳細をご覧ください。

カスタムソースセット ​

カスタムソースセットは、プロジェクトの開発者が手動で作成します。 カスタムソースセットを作成するには、sourceSets セクション内にその名前のセクションを追加します。 Kotlin Gradle DSL を使用している場合は、カスタムソースセットに by creating を付けます。

kotlin
kotlin {
    //...
    sourceSets { 
        val myMain by creating { /* ... */ } // 'myMain' という名前で新しいソースセットを作成
    }
}
groovy
kotlin {
    //...
    sourceSets { 
        myMain { /* ... */ } // 'myMain' という名前でソースセットを作成または設定
    }
}

新しく作成されたソースセットは、他のソースセットと接続されていないことに注意してください。プロジェクトのコンパイルで使用するには、他のソースセットと接続 する必要があります。

ソースセットパラメータ ​

ソースセットの設定は、sourceSets {} 内の対応するブロックに保存されます。ソースセットには以下のパラメータがあります。

名前説明
kotlin.srcDirソースセットディレクトリ内の Kotlin ソースファイルの場所。
resources.srcDirソースセットディレクトリ内のリソースの場所。
dependsOn別のソースセットとの接続。
dependenciesソースセットの 依存関係。
languageSettings共有ソースセットに適用される 言語設定。
kotlin
kotlin { 
    //...
    sourceSets { 
        commonMain {
            kotlin.srcDir("src")
            resources.srcDir("res")

            dependencies {
                /* ... */
            }
        }
    }
}
groovy
kotlin { 
    //...
    sourceSets { 
        commonMain {
            kotlin.srcDir('src')
            resources.srcDir('res')

            dependencies {
                /* ... */
            }
        }
    }
}

コンパイル ​

ターゲットは、製品用やテスト用など、1 つ以上のコンパイルを持つことができます。ターゲットの作成時に自動的に追加される 定義済みコンパイル があります。さらに カスタムコンパイル を作成することもできます。

ターゲットのすべてまたは一部の特定のコンパイルを参照するには、compilations オブジェクトコレクションを使用します。 compilations から、名前によってコンパイルを参照できます。

コンパイルの設定 についての詳細をご覧ください。

定義済みコンパイル ​

定義済みコンパイルは、Android ターゲットを除くプロジェクトの各ターゲットに対して自動的に作成されます。 利用可能な定義済みコンパイルは以下の通りです。

名前説明
main製品ソース用のコンパイル。
testテスト用のコンパイル。
kotlin
kotlin {
    jvm {
        val main by compilations.getting {
            output // メインコンパイルの出力を取得
        }

        compilations["test"].runtimeDependencyFiles // テストのランタイムクラスパスを取得
    }
}
groovy
kotlin {
    jvm {
        compilations.main.output // メインコンパイルの出力を取得
        compilations.test.runtimeDependencyFiles // テストのランタイムクラスパスを取得
    }
}

カスタムコンパイル ​

定義済みコンパイルに加えて、独自のカスタムコンパイルを作成できます。 そのためには、新しいコンパイルと main コンパイルの間に associateWith 関係を設定します。Kotlin Gradle DSL を使用している場合は、カスタムコンパイルに by creating を付けます。

kotlin
kotlin {
    jvm {
        compilations {
            val main by getting
            val integrationTest by creating {
                // main とそのクラスパスを依存関係としてインポートし、internal 可視性を確立する
                associateWith(main)
                defaultSourceSet {
                    dependencies {
                        implementation(kotlin("test-junit"))
                        /* ... */
                    }
                }

                // このコンパイルによって生成されたテストを実行するためのテストタスクを作成する
                testRuns.create("integration") {
                    // テストタスクの設定
                    setExecutionSourceFrom(integrationTest)
                }
            }
        }
    }
}
groovy
kotlin {
    jvm {
        compilations.create('integrationTest') {
            def main = compilations.main
            // main とそのクラスパスを依存関係としてインポートし、internal 可視性を確立する
            associateWith(main)
            defaultSourceSet {
                dependencies {
                    implementation kotlin('test-junit')
                    /* ... */
                }
            }

            // このコンパイルによって生成されたテストを実行するためのテストタスクを作成する
            testRuns.create('integration') {
                // テストタスクの設定
                setExecutionSourceFrom(compilations.integrationTest)
            }
        }
    }
}

コンパイルを関連付けることで、メインコンパイルの出力を依存関係として追加し、コンパイル間の internal 可視性を確立します。

カスタムコンパイルを作成 する方法についての詳細をご覧ください。

コンパイルパラメータ ​

コンパイルには以下のパラメータがあります。

名前説明
defaultSourceSetコンパイルのデフォルトソースセット。
kotlinSourceSetsコンパイルに参加するソースセット。
allKotlinSourceSetsコンパイルに参加するソースセットおよび dependsOn() を介したそれらの接続。
compilerOptionsコンパイルに適用されるコンパイラオプション。利用可能なオプションのリストについては、コンパイラオプション を参照してください。
compileKotlinTaskKotlin ソースをコンパイルするための Gradle タスク。
compileKotlinTaskNamecompileKotlinTask の名前。
compileAllTaskNameコンパイルのすべてのソースをコンパイルするための Gradle タスクの名前。
outputコンパイルの出力。
compileDependencyFilesコンパイルのコンパイル時依存関係ファイル(クラスパス)。すべての Kotlin/Native コンパイルにおいて、これには標準ライブラリとプラットフォーム依存関係が自動的に含まれます。
runtimeDependencyFilesコンパイルのランタイム依存関係ファイル(クラスパス)。
kotlin
kotlin {
    jvm {
        val main by compilations.getting {
            compileTaskProvider.configure {
                compilerOptions {
                    // 'main' コンパイル用の Kotlin コンパイラオプションを設定:
                    jvmTarget.set(JvmTarget.JVM_1_8)
                }
            }
        
            compileKotlinTask // Kotlin タスク 'compileKotlinJvm' を取得 
            output // メインコンパイルの出力を取得
        }
        
        compilations["test"].runtimeDependencyFiles // テストのランタイムクラスパスを取得
    }

    // すべてのターゲットのすべてのコンパイルを設定:
    compilerOptions {
        allWarningsAsErrors.set(true)
    }
}
groovy
kotlin {
    jvm {
        compilations.main {
            compileTaskProvider.configure {
                compilerOptions {
                    // 'main' コンパイル用の Kotlin コンパイラオプションを設定:
                    jvmTarget = JvmTarget.JVM_1_8
                }
            }
        }

        compilations.main.compileKotlinTask // Kotlin タスク 'compileKotlinJvm' を取得 
        compilations.main.output // メインコンパイルの出力を取得
        compilations.test.runtimeDependencyFiles // テストのランタイムクラスパスを取得
    }

    // すべてのターゲットのすべてのコンパイルを設定:
    compilerOptions {
        allWarningsAsErrors = true
    }
}

コンパイラオプション ​

プロジェクトのコンパイラオプションは、3 つの異なるレベルで設定できます。

  • 拡張(Extension)レベル: kotlin {} ブロック内。
  • ターゲット(Target)レベル: 各ターゲットブロック内。
  • コンパイル単位(Compilation unit)レベル: 通常、特定のコンパイルタスク内。

Kotlin コンパイラオプションのレベル

上位レベルの設定は、下位レベルのデフォルトとして機能します。

  • 拡張レベルで設定されたコンパイラオプションは、ターゲットレベルのオプションのデフォルトになります。これには、commonMain、nativeMain、commonTest などの共有ソースセットも含まれます。
  • ターゲットレベルで設定されたコンパイラオプションは、compileKotlinJvm や compileTestKotlinJvm タスクなどのコンパイル単位(タスク)レベルのオプションのデフォルトになります。

下位レベルで行われた設定は、上位レベルの同様の設定を上書きします。

  • タスクレベルのコンパイラオプションは、ターゲットまたは拡張レベルの同様の設定を上書きします。
  • ターゲットレベルのコンパイラオプションは、拡張レベルの同様の設定を上書きします。

利用可能なコンパイラオプションのリストについては、すべてのコンパイラオプション を参照してください。

拡張レベル ​

プロジェクト内のすべてのターゲットに対してコンパイラオプションを設定するには、トップレベルの compilerOptions {} ブロックを使用します。

kotlin
kotlin {
    // すべてのターゲットのすべてのコンパイルを設定
    compilerOptions {
        allWarningsAsErrors.set(true)
    }
}
groovy
kotlin {
    // すべてのターゲットのすべてのコンパイルを設定:
    compilerOptions {
        allWarningsAsErrors = true
    }
}

ターゲットレベル ​

プロジェクト内の特定のターゲットに対してコンパイラオプションを設定するには、ターゲットブロック内の compilerOptions {} ブロックを使用します。

kotlin
kotlin {
    jvm {
        // JVM ターゲットのすべてのコンパイルを設定
        compilerOptions {
            allWarningsAsErrors.set(true)
        }
    }
}
groovy
kotlin {
    jvm {
        // JVM ターゲットのすべてのコンパイルを設定
        compilerOptions {
            allWarningsAsErrors = true
        }
    }
}

コンパイル単位レベル ​

特定のタスクに対してコンパイラオプションを設定するには、タスク内の compilerOptions {} ブロックを使用します。

kotlin
task.named<KotlinJvmCompile>("compileKotlinJvm") {
    compilerOptions {
        allWarningsAsErrors.set(true)
    }
}
groovy
task.named<KotlinJvmCompile>("compileKotlinJvm") {
    compilerOptions {
        allWarningsAsErrors = true
    }
}

特定のコンパイルに対してコンパイラオプションを設定するには、コンパイルのタスクプロバイダー内で compilerOptions {} ブロックを使用します。

kotlin
kotlin {
    jvm {
        compilations.named(KotlinCompilation.MAIN_COMPILATION_NAME) {
            compileTaskProvider.configure {
                // 'main' コンパイルを設定:
                compilerOptions {
                    allWarningsAsErrors.set(true)
                }
            }
        }
    }
}
groovy
kotlin {
    jvm {
        compilations.named(KotlinCompilation.MAIN_COMPILATION_NAME) {
            compileTaskProvider.configure {
                // 'main' コンパイルを設定:
                compilerOptions {
                    allWarningsAsErrors = true
                }
            }
        }
    }
}

kotlinOptions {} から compilerOptions {} への移行 ​

Kotlin 2.2.0 より前は、kotlinOptions {} ブロックを使用してコンパイラオプションを設定できました。Kotlin 2.2.0 で kotlinOptions {} ブロックが非推奨になったため、代わりにビルドスクリプトで compilerOptions {} ブロックを使用する必要があります。詳細については、kotlinOptions{} から compilerOptions{} への移行 を参照してください。

依存関係 ​

ソースセット宣言の dependencies {} ブロックには、そのソースセットの依存関係が含まれます。

依存関係の設定 についての詳細をご覧ください。

依存関係には 4 つのタイプがあります。

名前説明
api現在のモジュールの API で使用される依存関係。
implementationモジュール内で使用されるが、モジュール外部には公開されない依存関係。
compileOnly現在のモジュールのコンパイルにのみ使用される依存関係。
runtimeOnly実行時に利用可能だが、どのモジュールのコンパイル時にも表示されない依存関係。
kotlin
kotlin {
    //...
    sourceSets {
        commonMain {
            dependencies {
                api("com.example:foo-metadata:1.0")
            }
        }
        jvmMain {
            dependencies {
                implementation("com.example:foo-jvm:1.0")
            }
        }
    }
}
groovy
kotlin {
    //...
    sourceSets {
        commonMain {
            dependencies {
                api 'com.example:foo-metadata:1.0'
            }
        }
        jvmMain {
            dependencies {
                implementation 'com.example:foo-jvm:1.0'
            }
        }
    }
}

さらに、ソースセットは互いに依存して階層を形成することができます。 この場合、dependsOn() 関係が使用されます。

Experimental

トップレベルでの依存関係の設定

トップレベルの dependencies {} ブロックを使用して、共通の依存関係を設定できます。ここで宣言された依存関係は、commonMain または commonTest ソースセットに追加された場合と同様に動作します。

トップレベルの dependencies {} ブロックを使用するには、ブロックの前に @OptIn(ExperimentalKotlinGradlePluginApi::class) アノテーションを追加してオプトインしてください。

kotlin
kotlin {
    @OptIn(ExperimentalKotlinGradlePluginApi::class)
    dependencies {
        implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.11.0")
    }
}
groovy
kotlin {
    dependencies {
        implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.11.0'
    }
}

プラットフォーム固有の依存関係は、対応するターゲットの sourceSets {} ブロック内に追加してください。

この機能に関するフィードバックは YouTrack で共有できます。

言語設定 ​

ソースセット内の languageSettings {} ブロックは、プロジェクトの解析とコンパイルの特定の側面を定義します。languageSettings {} ブロックは、特に共有ソースセットに適用される設定を構成する場合にのみ使用してください。それ以外のすべてのケースでは、拡張またはターゲットレベルで コンパイラオプションを設定 するために compilerOptions {} ブロックを使用してください。

以下の言語設定が利用可能です。

名前説明
languageVersion指定されたバージョンの Kotlin とのソース互換性を提供します。
apiVersion指定されたバージョンの Kotlin バンドルライブラリの宣言のみを使用できるようにします。
enableLanguageFeature指定された言語機能を有効にします。利用可能な値は、現在実験的な、あるいはかつて実験的として導入された言語機能に対応しています。
optIn指定された オプトインアノテーション の使用を許可します。
progressiveModeプログレッシブモード を有効にします。
kotlin
kotlin {
    sourceSets.all {
        languageSettings.apply {
            languageVersion = "2.4" // 指定可能な値: "2.0", "2.1", "2.2", "2.3", "2.4", "2.5" (EXPERIMENTAL)
            apiVersion = "2.4" // 指定可能な値: "2.0", "2.1", "2.2", "2.3", "2.4", "2.5" (EXPERIMENTAL)
            enableLanguageFeature("InlineClasses") // 言語機能名
            optIn("kotlin.ExperimentalUnsignedTypes") // アノテーションの完全修飾名
            progressiveMode = true // デフォルトは false
        }
    }
}
groovy
kotlin {
    sourceSets.all {
        languageSettings {
            languageVersion = '2.4' // 指定可能な値: '2.0', '2.1', '2.2', '2.3', '2.4', '2.5' (EXPERIMENTAL)
            apiVersion = '2.4' // 指定可能な値: '2.0', '2.1', '2.2', '2.3', '2.4', '2.5' (EXPERIMENTAL)
            enableLanguageFeature('InlineClasses') // 言語機能名
            optIn('kotlin.ExperimentalUnsignedTypes') // アノテーションの完全修飾名
            progressiveMode = true // デフォルトは false
        }
    }
}