pluginManagement {
    includeBuild("repo/gradle-settings-conventions")
    includeBuild("repo/gradle-build-conventions")

    apply from: 'repo/scripts/cache-redirector.settings.gradle.kts'
    apply from: 'repo/scripts/kotlin-bootstrap.settings.gradle.kts'

    repositories {
        maven {
            url "https://packages.jetbrains.team/maven/p/ij/intellij-dependencies"
            content {
                includeGroupByRegex("org\\.jetbrains\\.intellij\\.deps(\\..+)?")
            }
        }
        maven { url "https://maven.pkg.jetbrains.space/kotlin/p/kotlin/kotlin-dependencies" }
        google()
        mavenCentral()
        gradlePluginPortal()
    }

    plugins {
        id "de.undercouch.download" version "5.1.0"
    }
}

plugins {
    id "internal-gradle-setup" // it's recommended to apply this plugin at first, as it changes the local.properties file
    id "develocity"
    id "jvm-toolchain-provisioning"
    id "kotlin-daemon-config"
}

File versionPropertiesFile = new File(rootProject.projectDir, "gradle/versions.properties")
def versionProperties = new Properties()
versionPropertiesFile.withInputStream {
    versionProperties.load(it)
}
dependencyResolutionManagement {
    components {
        withModule("com.google.code.gson:gson") {
            allVariants {
                withDependencies {
                    add("com.google.code.gson:gson") {
                        version {
                            it.require(versionProperties['versions.gson'] as String)
                        }
                    }
                }
            }
        }

        withModule("org.apache.commons:commons-compress") {
            allVariants {
                withDependencies {
                    add("org.apache.commons:commons-compress") {
                        version {
                            it.require(versionProperties['versions.commons-compress'] as String)
                        }
                    }
                }
            }
        }

        withModule("commons-io:commons-io") {
            allVariants {
                withDependencies {
                    add("commons-io:commons-io") {
                        version {
                            it.require(versionProperties['versions.commons-io'] as String)
                        }
                    }
                }
            }
        }
    }

    versionCatalogs {
        create("composeRuntimeSnapshot") {
            from(files("plugins/compose/compose-runtime-snapshot-versions.toml"))
        }
    }
}

def buildProperties = BuildPropertiesKt.getKotlinBuildPropertiesForSettings(settings)

// modules
include ":benchmarks",
        ":compiler",
        ":compiler:util",
        ":compiler:config",
        ":compiler:config.jvm",
        ":compiler:config:configuration-keys-generator",
        ":kotlin-util-io",
        ":kotlin-util-klib",
        ":kotlin-util-klib-metadata",
        ":kotlin-util-klib-abi",
        ":daemon-common",
        ":kotlin-daemon",
        ":kotlin-daemon-client",
        ":kotlin-daemon-tests",
        ":kotlin-preloader",
        ":kotlin-runner",
        ":compiler:container",
        ":compiler:resolution.common",
        ":compiler:resolution.common.jvm",
        ":compiler:resolution",
        ":compiler:serialization",
        ":compiler:psi",
        ":compiler:frontend",
        ":compiler:frontend.common",
        ":compiler:frontend.common-psi",
        ":compiler:frontend.java",
        ":compiler:frontend:cfg",
        ":kotlin-compiler-runner-unshaded",
        ":kotlin-compiler-runner",
        ":compiler:ir.tree",
        ":compiler:ir.tree:tree-generator",
        ":compiler:ir.psi2ir",
        ":compiler:ir.objcinterop",
        ":compiler:ir.backend.common",
        ":compiler:ir.backend.native",
        ":compiler:ir.actualization",
        ":compiler:ir.serialization.common",
        ":compiler:ir.serialization.jvm",
        ":compiler:ir.serialization.js",
        ":compiler:ir.serialization.native",
        ":compiler:ir.interpreter",
        ":compiler:ir.inline",
        ":compiler:backend.js",
        ":compiler:backend.wasm",
        ":compiler:backend.jvm",
        ":compiler:backend.jvm.lower",
        ":compiler:backend.jvm.codegen",
        ":compiler:backend.jvm.entrypoint",
        ":compiler:backend-common",
        ":compiler:backend",
        ":compiler:plugin-api",
        ":compiler:light-classes",
        ":compiler:javac-wrapper",
        ":compiler:cli-common",
        ":compiler:cli-base",
        ":compiler:cli",
        ":compiler:cli-js",
        ":compiler:incremental-compilation-impl",
        ":compiler:tests-compiler-utils",
        ":compiler:tests-common",
        ":compiler:tests-integration",
        ":compiler:tests-mutes",
        ":compiler:tests-mutes:tc-integration",
        ":compiler:tests-mutes:mutes-junit4",
        ":compiler:tests-mutes:mutes-junit5",
        ":compiler:tests-against-klib",
        ":compiler:tests-for-compiler-generator",
        ":js:js.ast",
        ":js:js.sourcemap",
        ":js:js.serializer",
        ":js:js.parser",
        ":js:js.config",
        ":js:js.frontend",
        ":js:js.translator",
        ":js:js.tests",
        ":js:js.tests:klib-compatibility",
        ":native:kotlin-native-utils",
        ":native:frontend.native",
        ":native:kotlin-klib-commonizer",
        ":native:kotlin-klib-commonizer-api",
        ":native:kotlin-klib-commonizer-embeddable",
        ":native:executors",
        ":native:base",
        ":native:analysis-api-klib-reader",
        ":native:analysis-api-klib-reader:testProject",
        ":native:objcexport-header-generator",
        ":native:objcexport-header-generator-k1",
        ":native:objcexport-header-generator-analysis-api",
        ":native:objcexport-header-generator:testLibraryA",
        ":native:objcexport-header-generator:testLibraryB",
        ":native:objcexport-header-generator:testLibraryC",
        ":native:objcexport-header-generator:testInternalLibrary",
        ":native:objcexport-header-generator:testExtensionsLibrary",
        ":core:compiler.common",
        ":core:compiler.common.jvm",
        ":core:compiler.common.js",
        ":core:compiler.common.native",
        ":core:compiler.common.wasm",
        ":core:compiler.common.web",
        ":compiler:backend.common.jvm",
        ":core:descriptors",
        ":core:descriptors.jvm",
        ":core:deserialization",
        ":core:descriptors.runtime",
        ":core:metadata",
        ":core:metadata.jvm",
        ":core:deserialization.common",
        ":core:deserialization.common.jvm",
        ":compiler:frontend.common.jvm",
        ":core:util.runtime",
        ":compiler:compiler.version",
        ":dependencies:android-sdk",
        ":dependencies:tools-jar-api",
        ":dependencies:intellij-core",
        ":plugins:android-extensions-compiler",
        ":kotlin-android-extensions",
        ":kotlin-android-extensions-runtime"

include ":kotlin-allopen-compiler-plugin",
        ":kotlin-allopen-compiler-plugin.embeddable",
        ":kotlin-allopen-compiler-plugin.common",
        ":kotlin-allopen-compiler-plugin.k1",
        ":kotlin-allopen-compiler-plugin.k2",
        ":kotlin-allopen-compiler-plugin.cli"

include ":kotlin-noarg-compiler-plugin",
        ":kotlin-noarg-compiler-plugin.embeddable",
        ":kotlin-noarg-compiler-plugin.common",
        ":kotlin-noarg-compiler-plugin.k1",
        ":kotlin-noarg-compiler-plugin.k2",
        ":kotlin-noarg-compiler-plugin.backend",
        ":kotlin-noarg-compiler-plugin.cli"

include ":kotlin-power-assert-compiler-plugin",
        ":kotlin-power-assert-compiler-plugin.embeddable",
        ":kotlin-power-assert-compiler-plugin.backend",
        ":kotlin-power-assert-compiler-plugin.cli"

include ":kotlin-sam-with-receiver-compiler-plugin",
        ":kotlin-sam-with-receiver-compiler-plugin.embeddable",
        ":kotlin-sam-with-receiver-compiler-plugin.common",
        ":kotlin-sam-with-receiver-compiler-plugin.k1",
        ":kotlin-sam-with-receiver-compiler-plugin.k2",
        ":kotlin-sam-with-receiver-compiler-plugin.cli"

include ":kotlin-assignment-compiler-plugin",
        ":kotlin-assignment-compiler-plugin.common",
        ":kotlin-assignment-compiler-plugin.k1",
        ":kotlin-assignment-compiler-plugin.k2",
        ":kotlin-assignment-compiler-plugin.cli",
        ":kotlin-assignment-compiler-plugin.embeddable"

include ":plugins:plugins-interactions-testing"

include ":kotlin-imports-dumper-compiler-plugin",
        ":kotlin-script-runtime",
        ":plugins:plugin-sandbox",
        ":plugins:plugin-sandbox:plugin-annotations",
        ":plugins:plugin-sandbox:plugin-sandbox-ic-test",
        ":kotlin-metadata",
        ":kotlin-metadata-jvm",
        ":kotlinx-metadata-klib",
        ":prepare:build.version",
        ":kotlin-build-common",
        ":prepare:kotlin-compiler-internal-test-framework",
        ":kotlin-compiler",
        ":kotlin-compiler-embeddable",
        ":kotlin-compiler-client-embeddable",
        ":kotlin-reflect",
        ":kotlin-reflect-api",
        ":kotlin-ant",
        ":compiler:tests-java8",
        ":compiler:tests-different-jdk",
        ":compiler:tests-spec",
        ":generators",
        ":generators:ide-iml-to-gradle-generator",
        ":generators:test-generator",
        ":generators:tree-generator-common",
        ":tools:kotlinp",
        ":tools:kotlinp-jvm",
        ":tools:kotlinp-klib",
        ":kotlin-build-tools-enum-compat",
        ":kotlin-gradle-compiler-types",
        ":kotlin-gradle-plugin-api",
        ":kotlin-gradle-plugin-annotations",
        ":kotlin-gradle-plugin-idea",
        ":kotlin-gradle-plugin-idea-proto",
        ":kotlin-gradle-plugin-idea-for-compatibility-tests",
        ":analysis:analysis-tools:deprecated-k1-frontend-internals-for-ide-generator",
        ":analysis:analysis-tools:deprecated-k1-frontend-internals-for-ide-generated",
        ":analysis:analysis-tools:analysis-api-kdoc-coverage-test",
        ":kotlin-gradle-plugin-dsl-codegen",
        ":kotlin-gradle-plugin-npm-versions-codegen",
        ":kotlin-gradle-statistics",
        ":kotlin-gradle-build-metrics",
        ":kotlin-gradle-plugin",
        ":kotlin-gradle-plugin-tcs-android",
        ":kotlin-gradle-plugin-model",
        ":kotlin-gradle-plugin-test-utils-embeddable",
        ":kotlin-gradle-plugin-integration-tests",
        ":kotlin-gradle-plugins-bom",
        ":kotlin-privacy-manifests-plugin",
        ":compiler:build-tools:kotlin-build-statistics",
        ":gradle:android-test-fixes",
        ":gradle:documentation",
        ":gradle:gradle-warnings-detector",
        ":gradle:kotlin-compiler-args-properties",
        ":gradle:regression-benchmark-templates",
        ":gradle:regression-benchmarks",
        ":libraries:tools:gradle:fus-statistics-gradle-plugin",
        ":kotlin-tooling-metadata",
        ":kotlin-tooling-core",
        ":compose-compiler-gradle-plugin",
        ":kotlin-allopen",
        ":kotlin-noarg",
        ":kotlin-power-assert",
        ":kotlin-sam-with-receiver",
        ":kotlin-assignment",
        ":kotlin-gradle-subplugin-example",
        ":examples:annotation-processor-example",
        ":kotlin-annotation-processing",
        ":kotlin-annotation-processing-cli",
        ":kotlin-annotation-processing-base",
        ":kotlin-annotation-processing-runtime",
        ":kotlin-annotation-processing-embeddable",
        ":kotlin-daemon-embeddable",
        ":kotlin-annotations-jvm",
        ":kotlin-scripting-common",
        ":kotlin-scripting-jvm",
        ":kotlin-scripting-jvm-host-unshaded",
        ":kotlin-scripting-jvm-host-test",
        ":kotlin-scripting-jvm-host",
        ":kotlin-scripting-intellij",
        ":kotlin-scripting-compiler",
        ":kotlin-scripting-compiler-embeddable",
        ":kotlin-scripting-compiler-impl",
        ":kotlin-scripting-compiler-impl-embeddable",
        ":plugins:scripting:test-script-definition",
        ":plugins:scripting:scripting-tests",
        ":kotlin-scripting-dependencies",
        ":kotlin-scripting-dependencies-maven",
        ":kotlin-scripting-dependencies-maven-all",
        ":kotlin-scripting-jsr223-unshaded",
        ":kotlin-scripting-jsr223-test",
        ":kotlin-scripting-jsr223",
        ":kotlin-main-kts",
        ":kotlin-main-kts-test",
        ":examples:scripting-jvm-simple-script",
        ":examples:scripting-jvm-simple-script-host",
        ":examples:scripting-jvm-maven-deps",
        ":examples:scripting-jvm-maven-deps-host",
        ":examples:scripting-jvm-embeddable-host",
        ":pill:pill-importer",
        ":pill:generate-all-tests",
        ":libraries:kotlin-prepush-hook",
        ":libraries:tools:mutability-annotations-compat",
        ":plugins:jvm-abi-gen",
        ":plugins:jvm-abi-gen-embeddable",
        ":test-instrumenter",
        ":wasm:wasm.ir",
        ":wasm:wasm.tests",
        ":wasm:wasm.frontend",
        ":wasm:wasm.config",
        ":wasm:wasm.debug.browsers",
        ":repo:codebase-tests",
        ":repo:artifacts-tests"

include ":libraries:tools:abi-comparator"

include ":libraries:tools:abi-validation:abi-tools",
        ":libraries:tools:abi-validation:abi-tools-api"

include ":kotlin-atomicfu-compiler-plugin",
        ":kotlin-atomicfu-compiler-plugin-embeddable",
        ":kotlinx-atomicfu-runtime",
        ":atomicfu"

include ":plugins:js-plain-objects:compiler-plugin",
        ":plugins:js-plain-objects:compiler-plugin-embeddable",
        ":plugins:js-plain-objects:compiler-plugin:js-plain-objects.common",
        ":plugins:js-plain-objects:compiler-plugin:js-plain-objects.k2",
        ":plugins:js-plain-objects:compiler-plugin:js-plain-objects.backend",
        ":plugins:js-plain-objects:compiler-plugin:js-plain-objects.cli"

if (!buildProperties.inJpsBuildIdeaSync) {
    include ":plugins:js-plain-objects:runtime",
            ":libraries:tools:js-plain-objects"
}

include ":compiler:fir",
        ":compiler:fir:cones",
        ":compiler:fir:tree",
        ":compiler:fir:tree:tree-generator",
        ":compiler:fir:raw-fir:raw-fir.common",
        ":compiler:fir:raw-fir:psi2fir",
        ":compiler:fir:raw-fir:light-tree2fir",
        ":compiler:fir:fir2ir",
        ":compiler:fir:fir2ir:jvm-backend",
        ":compiler:fir:providers",
        ":compiler:fir:semantics",
        ":compiler:fir:resolve",
        ":compiler:fir:plugin-utils",
        ":compiler:fir:fir-serialization",
        ":compiler:fir:fir-deserialization",
        ":compiler:fir:java",
        ":compiler:fir:native",
        ":compiler:fir:modularized-tests",
        ":compiler:fir:dump",
        ":compiler:fir:checkers",
        ":compiler:fir:checkers:checkers.jvm",
        ":compiler:fir:checkers:checkers.js",
        ":compiler:fir:checkers:checkers.native",
        ":compiler:fir:checkers:checkers.wasm",
        ":compiler:fir:checkers:checkers.web.common",
        ":compiler:fir:checkers:checkers-component-generator",
        ":compiler:fir:entrypoint",
        ":compiler:fir:analysis-tests",
        ":compiler:fir:analysis-tests:legacy-fir-tests"

include ":kotlin-scripting-ide-services-unshaded",
        ":kotlin-scripting-ide-services-test",
        ":kotlin-scripting-ide-services",
        ":kotlin-scripting-ide-common"

include ":compiler:test-infrastructure",
        ":compiler:test-infrastructure-utils",
        ":compiler:tests-common-new"

include ":plugins:parcelize:parcelize-compiler",
        ":plugins:parcelize:parcelize-compiler:parcelize.common",
        ":plugins:parcelize:parcelize-compiler:parcelize.k1",
        ":plugins:parcelize:parcelize-compiler:parcelize.k2",
        ":plugins:parcelize:parcelize-compiler:parcelize.backend",
        ":plugins:parcelize:parcelize-compiler:parcelize.cli",
        ":plugins:parcelize:parcelize-runtime",
        ":kotlin-parcelize-compiler"

include ":kotlin-lombok-compiler-plugin",
        ":kotlin-lombok-compiler-plugin.embeddable",
        ":kotlin-lombok-compiler-plugin.common",
        ":kotlin-lombok-compiler-plugin.k1",
        ":kotlin-lombok-compiler-plugin.k2",
        ":kotlin-lombok-compiler-plugin.cli",
        ":kotlin-lombok"

include ":kotlinx-serialization-compiler-plugin",
        ":kotlinx-serialization-compiler-plugin.embeddable",
        ":kotlinx-serialization-compiler-plugin.common",
        ":kotlinx-serialization-compiler-plugin.k1",
        ":kotlinx-serialization-compiler-plugin.k2",
        ":kotlinx-serialization-compiler-plugin.backend",
        ":kotlinx-serialization-compiler-plugin.cli",
        ":kotlin-serialization",
        ":kotlin-serialization-unshaded"

if (!buildProperties.inJpsBuildIdeaSync) {
    include ":prepare:ide-plugin-dependencies:android-extensions-compiler-plugin-for-ide",
            ":prepare:ide-plugin-dependencies:allopen-compiler-plugin-for-ide",
            ":prepare:ide-plugin-dependencies:scripting-compiler-plugin-for-ide",
            ":prepare:ide-plugin-dependencies:allopen-compiler-plugin-tests-for-ide",
            ":prepare:ide-plugin-dependencies:compose-compiler-plugin-for-ide",
            ":prepare:ide-plugin-dependencies:js-plain-objects-compiler-plugin-for-ide",
            ":prepare:ide-plugin-dependencies:incremental-compilation-impl-tests-for-ide",
            ":prepare:ide-plugin-dependencies:js-ir-runtime-for-ide",
            ":prepare:ide-plugin-dependencies:kotlin-build-common-tests-for-ide",
            ":prepare:ide-plugin-dependencies:kotlin-compiler-cli-for-ide",
            ":prepare:ide-plugin-dependencies:kotlin-dist-for-ide",
            ":prepare:ide-plugin-dependencies:kotlin-gradle-statistics-for-ide",
            ":prepare:ide-plugin-dependencies:kotlin-jps-common-for-ide",
            ":prepare:ide-plugin-dependencies:kotlin-jps-plugin-classpath",
            ":prepare:ide-plugin-dependencies:kotlin-jps-plugin-tests-for-ide",
            ":prepare:ide-plugin-dependencies:kotlin-jps-plugin-testdata-for-ide",
            ":prepare:ide-plugin-dependencies:kotlinx-serialization-compiler-plugin-for-ide",
            ":prepare:ide-plugin-dependencies:noarg-compiler-plugin-for-ide",
            ":prepare:ide-plugin-dependencies:sam-with-receiver-compiler-plugin-for-ide",
            ":prepare:ide-plugin-dependencies:assignment-compiler-plugin-for-ide",
            ":prepare:ide-plugin-dependencies:parcelize-compiler-plugin-for-ide",
            ":prepare:ide-plugin-dependencies:lombok-compiler-plugin-for-ide",
            ":prepare:ide-plugin-dependencies:kotlin-objcexport-header-generator-for-ide",
            ":prepare:ide-plugin-dependencies:kotlin-swift-export-for-ide",
            ":prepare:ide-plugin-dependencies:kotlin-compiler-testdata-for-ide",
            ":prepare:ide-plugin-dependencies:kotlin-compiler-tests-for-ide",
            ":prepare:ide-plugin-dependencies:low-level-api-fir-for-ide",
            ":prepare:ide-plugin-dependencies:analysis-api-for-ide",
            ":prepare:ide-plugin-dependencies:analysis-api-impl-base-for-ide",
            ":prepare:ide-plugin-dependencies:analysis-api-impl-base-tests-for-ide",
            ":prepare:ide-plugin-dependencies:analysis-api-k2-for-ide",
            ":prepare:ide-plugin-dependencies:analysis-api-k2-tests-for-ide",
            ":prepare:ide-plugin-dependencies:analysis-api-fe10-for-ide",
            ":prepare:ide-plugin-dependencies:analysis-api-fe10-tests-for-ide",
            ":prepare:ide-plugin-dependencies:analysis-api-platform-interface-for-ide",
            ":prepare:ide-plugin-dependencies:symbol-light-classes-for-ide",
            ":prepare:ide-plugin-dependencies:analysis-api-standalone-for-ide",
            ":prepare:ide-plugin-dependencies:kotlin-compiler-ir-for-ide",
            ":prepare:ide-plugin-dependencies:kotlin-compiler-common-for-ide",
            ":prepare:ide-plugin-dependencies:kotlin-compiler-fe10-for-ide",
            ":prepare:ide-plugin-dependencies:kotlin-compiler-fir-for-ide"
}

include ":compiler:build-tools:kotlin-build-tools-api",
        ":compiler:build-tools:kotlin-build-tools-impl",
        ":compiler:build-tools:kotlin-build-tools-api-tests",
        ":compiler:build-tools:kotlin-build-tools-jdk-utils"

if (!buildProperties.inJpsBuildIdeaSync) {
    include ":plugins:compose-compiler-plugin",
            ":plugins:compose-compiler-plugin:compiler",
            ":plugins:compose-compiler-plugin:compiler-hosted",
            ":plugins:compose-compiler-plugin:compiler-hosted:integration-tests",
            ":plugins:compose-compiler-plugin:compiler-hosted:integration-tests:protobuf-test-classes"

    if (buildProperties.inIdeaSync) {
        include ":plugins:compose-compiler-plugin:compiler-hosted:runtime-tests"
    }
}

// Swift Export modules
include ":native:swift:sir",
        ":native:swift:sir:tree-generator",
        ":native:swift:sir-light-classes",
        ":native:swift:sir-printer",
        ":native:swift:sir-compiler-bridge",
        ":native:swift:sir-providers",
        ":native:swift:swift-export-standalone",
        ":native:swift:swift-export-embeddable",
        ":native:swift:swift-export-ide",
        ":generators:sir-tests-generator"

void intellij(String imlPath) {
    File imlFile = new File("${rootDir}/intellij/community/plugins/kotlin/${imlPath}")
    imlFile = imlFile.exists() ? imlFile : new File("${rootDir}/intellij/plugins/kotlin/${imlPath}")
    imlFile = imlFile.exists() ? imlFile : new File("${rootDir}/intellij/community/${imlPath}")
    imlFile = imlFile.exists() ? imlFile : new File("${rootDir}/intellij/${imlPath}")
    if (!imlFile.exists()) {
        throw new IllegalStateException("$imlFile doesn't exist. Please, update mapping in settings.gradle. And regenerate " +
                "build.gradle files in kt-branch in 'intellij' repo (./gradlew generateIdePluginGradleFiles). Or you can " +
                "remove 'attachedIntellijVersion' in your 'local.properties' if you don't care about being possible to" +
                "browse Kotlin plugin sources in scope of Kotlin compiler sources")
    }
    String fileName = imlFile.name
    String projectName = ":kotlin-ide.${fileName.substring(0, fileName.length() - ".iml".length())}"
    include(projectName)
    project(projectName).projectDir = imlFile.parentFile
}

String attachedIntellijVersion = buildProperties.getOrNull("attachedIntellijVersion")
if (attachedIntellijVersion == "212") { // Latest available platform in scope of KT release cycle
    logger.info("Including kotlin-ide modules in settings.gradle")
    intellij "java/compiler/intellij.java.compiler.tests.iml"
    intellij "platform/testFramework/extensions/intellij.platform.testExtensions.iml"
    intellij "platform/lang-impl/intellij.platform.lang.tests.iml"
    intellij "platform/xdebugger-testFramework/intellij.platform.debugger.testFramework.iml"
    intellij "platform/external-system-impl/intellij.platform.externalSystem.tests.iml"
    intellij "jvm-debugger/core/kotlin.jvm-debugger.core.iml"
    intellij "jvm-debugger/util/kotlin.jvm-debugger.util.iml"
    intellij "jvm-debugger/eval4j/kotlin.eval4j.iml"
    intellij "jvm-debugger/test/kotlin.jvm-debugger.test.iml"
    intellij "jvm-debugger/evaluation/kotlin.jvm-debugger.evaluation.iml"
    intellij "jvm-debugger/coroutines/kotlin.jvm-debugger.coroutines.iml"
    intellij "jvm-debugger/sequence/kotlin.jvm-debugger.sequence.iml"
    intellij "jvm/kotlin.jvm.iml"
    intellij "core/kotlin.core.iml"
    intellij "common/kotlin.common.iml"
    intellij "tests-common/kotlin.tests-common.iml"
    intellij "j2k/services/kotlin.j2k.services.iml"
    intellij "j2k/old/kotlin.j2k.old.iml"
    intellij "j2k/old/tests/kotlin.j2k.old.tests.iml"
    intellij "j2k/idea/kotlin.j2k.idea.iml"
    intellij "j2k/new/tests/kotlin.j2k.new.tests.iml"
    intellij "j2k/new/kotlin.j2k.new.iml"
    intellij "fir-low-level-api-ide-impl/kotlin.fir.fir-low-level-api-ide-impl.iml"
    intellij "fir-analysis-project-structure-ide-impl/kotlin.fir.analysis-project-structure-ide-impl.iml"
    intellij "analysis-api-providers-ide-impl/kotlin.fir.analysis-api-providers-ide-impl.iml"
    intellij "native/kotlin.native.iml"
    intellij "performance-tests/kotlin.performance-tests.iml"
    intellij "injection/kotlin.injection.iml"
    intellij "resources-fe10/kotlin.resources-fe10.iml"
    intellij "git/kotlin.git.iml"
    intellij "idea/tests/kotlin.idea.tests.iml"
    intellij "idea/kotlin.idea.iml"
    intellij "project-wizard/core/kotlin.project-wizard.core.iml"
    intellij "project-wizard/idea/kotlin.project-wizard.idea.iml"
    intellij "project-wizard/cli/kotlin.project-wizard.cli.iml"
    intellij "resources-fir/kotlin.resources-fir.iml"
    intellij "kotlin.all-tests/kotlin.all-tests.iml"
    intellij "i18n/kotlin.i18n.iml"
    intellij "uast/uast-kotlin-idea-fir/kotlin.uast.uast-kotlin-idea-fir.iml"
    intellij "uast/uast-kotlin-idea/kotlin.uast.uast-kotlin-idea.iml"
    intellij "uast/uast-kotlin-fir/kotlin.uast.uast-kotlin-fir.iml"
    intellij "uast/uast-kotlin-base/kotlin.uast.uast-kotlin-base.iml"
    intellij "uast/uast-kotlin-idea-base/kotlin.uast.uast-kotlin-idea-base.iml"
    intellij "uast/uast-kotlin/kotlin.uast.uast-kotlin.iml"
    intellij "test-framework/kotlin.test-framework.iml"
    intellij "generators/kotlin.generators.iml"
    intellij "gradle/gradle-native/kotlin.gradle.gradle-native.iml"
    intellij "gradle/gradle-idea/kotlin.gradle.gradle-idea.iml"
    intellij "gradle/gradle-tooling/kotlin.gradle.gradle-tooling.iml"
    intellij "scripting/kotlin.scripting.iml"
    intellij "compiler-plugins/allopen/common/kotlin.compiler-plugins.allopen.common.iml"
    intellij "compiler-plugins/allopen/tests/kotlin.compiler-plugins.allopen.tests.iml"
    intellij "compiler-plugins/allopen/gradle/kotlin.compiler-plugins.allopen.gradle.iml"
    intellij "compiler-plugins/allopen/maven/kotlin.compiler-plugins.allopen.maven.iml"
    intellij "compiler-plugins/kapt/kotlin.compiler-plugins.kapt.iml"
    intellij "compiler-plugins/kotlinx-serialization/common/kotlin.compiler-plugins.kotlinx-serialization.common.iml"
    intellij "compiler-plugins/kotlinx-serialization/gradle/kotlin.compiler-plugins.kotlinx-serialization.gradle.iml"
    intellij "compiler-plugins/kotlinx-serialization/maven/kotlin.compiler-plugins.kotlinx-serialization.maven.iml"
    intellij "compiler-plugins/parcelize/common/kotlin.compiler-plugins.parcelize.common.iml"
    intellij "compiler-plugins/parcelize/tests/kotlin.compiler-plugins.parcelize.tests.iml"
    intellij "compiler-plugins/parcelize/gradle/kotlin.compiler-plugins.parcelize.gradle.iml"
    intellij "compiler-plugins/scripting/kotlin.compiler-plugins.scripting.iml"
    intellij "compiler-plugins/noarg/common/kotlin.compiler-plugins.noarg.common.iml"
    intellij "compiler-plugins/noarg/tests/kotlin.compiler-plugins.noarg.tests.iml"
    intellij "compiler-plugins/noarg/gradle/kotlin.compiler-plugins.noarg.gradle.iml"
    intellij "compiler-plugins/noarg/maven/kotlin.compiler-plugins.noarg.maven.iml"
    intellij "compiler-plugins/lombok/kotlin.compiler-plugins.lombok.iml"
    intellij "compiler-plugins/sam-with-receiver/common/kotlin.compiler-plugins.sam-with-receiver.common.iml"
    intellij "compiler-plugins/sam-with-receiver/gradle/kotlin.compiler-plugins.sam-with-receiver.gradle.iml"
    intellij "compiler-plugins/sam-with-receiver/maven/kotlin.compiler-plugins.sam-with-receiver.maven.iml"
    intellij "compiler-plugins/base-compiler-plugins-ide-support/kotlin.compiler-plugins.base-compiler-plugins-ide-support.iml"
    intellij "line-indent-provider/kotlin.line-indent-provider.iml"
    intellij "scripting-support/kotlin.scripting-support.iml"
    intellij "formatter/kotlin.formatter.iml"
    intellij "fir/kotlin.fir.iml"
    intellij "fir-fe10-binding/kotlin.fir.fir-fe10-binding.iml"
    intellij "maven/tests/kotlin.maven.tests.iml"
    intellij "maven/kotlin.maven.iml"
    intellij "frontend-independent/tests/kotlin.fir.frontend-independent.tests.iml"
    intellij "frontend-independent/kotlin.fir.frontend-independent.iml"
    intellij "kotlin-compiler-classpath/kotlin.util.compiler-classpath.iml"
    intellij "repl/kotlin.repl.iml"
    intellij "plugins/gradle/tooling-extension-impl/intellij.gradle.toolingExtension.tests.iml"
    intellij "plugins/gradle/intellij.gradle.tests.iml"
    intellij "plugins/maven/intellij.maven.iml"
    intellij "jvm-run-configurations/kotlin.jvm-run-configurations.iml"
}

if (attachedIntellijVersion == "master") {
    logger.info("Including kotlin-ide modules in settings.gradle")
    def excludedModules = [
            "tools/kotlin-maven-artifacts-publishing/intellij.kotlin.util.mavenArtifactsPublishing.iml",
            "util/project-model-updater/kotlin.util.project-model-updater.iml",
            "util/compiler-dependencies/kotlin.util.compiler-dependencies.iml",
            "kotlin-compiler-classpath/kotlin.util.compiler-classpath.iml"
    ]
    def modulesIml = new File("${rootDir}/intellij/.idea/modules.xml").text
    def matcher = modulesIml =~ /filepath="(.+)"/ // TODO use some xml parser instead
    def modules = (0..<matcher.count)
            .collect { matcher[it][1] }
            .findAll { it.startsWithAny('$PROJECT_DIR$/community/plugins/kotlin/', '$PROJECT_DIR$/plugins/kotlin/') }
            .collect {
                it.startsWith('$PROJECT_DIR$/community/plugins/kotlin/') ? (it - '$PROJECT_DIR$/community/plugins/kotlin/') :
                        (it.startsWith('$PROJECT_DIR$/plugins/kotlin/') ? (it - '$PROJECT_DIR$/plugins/kotlin/') : null)
            }
    (modules - excludedModules).each { intellij it }

    //// These modules are used in Kotlin plugin and IDEA doesn't publish artifact of these modules
    intellij "plugins/gradle/intellij.gradle.tests.iml"
    intellij "plugins/gradle/java/intellij.gradle.java.iml"
    intellij "plugins/gradle/jps-plugin/intellij.gradle.jps.iml"
    intellij "xml/relaxng/intellij.relaxng.iml"
    intellij "plugins/maven/intellij.maven.iml"
    intellij "jvm-run-configurations/kotlin.jvm-run-configurations.iml"
    intellij "java/compiler/intellij.java.compiler.tests.iml"
    intellij "platform/testFramework/extensions/intellij.platform.testExtensions.iml"
    intellij "platform/lang-impl/intellij.platform.lang.tests.iml"
    intellij "platform/xdebugger-testFramework/intellij.platform.debugger.testFramework.iml"
    intellij "platform/external-system-impl/intellij.platform.externalSystem.tests.iml"
    intellij "plugins/gradle/tooling-extension-impl/intellij.gradle.toolingExtension.tests.iml"
    intellij "jvm/jvm-analysis-tests/intellij.jvm.analysis.testFramework.iml"
    intellij "jvm/jvm-analysis-kotlin-tests/intellij.jvm.analysis.kotlin.tests.iml"
    intellij "platform/configuration-store-impl/intellij.platform.configurationStore.tests.iml"
    intellij "plugins/stats-collector/intellij.statsCollector.tests.iml"
    intellij "plugins/groovy/groovy-uast-tests/intellij.groovy.uast.tests.iml"
}

include ":jps:jps-common",
        ":jps:jps-plugin",
        ":prepare:kotlin-jps-plugin",
        ":jps:jps-platform-api-signatures"

include ":generators:analysis-api-generator",
        ":analysis",
        ":analysis:low-level-api-fir",
        ":analysis:low-level-api-fir:tests-jdk11",
        ":analysis:analysis-api-fir:analysis-api-fir-generator",
        ":analysis:analysis-api-fir",
        ":analysis:analysis-api",
        ":analysis:analysis-api-impl-base",
        ":analysis:analysis-api-platform-interface",
        ":analysis:analysis-internal-utils",
        ":analysis:analysis-test-framework",
        ":analysis:kt-references",
        ":analysis:symbol-light-classes",
        ":analysis:light-classes-base",
        ":analysis:analysis-api-standalone",
        ":analysis:analysis-api-standalone:analysis-api-standalone-base",
        ":analysis:analysis-api-standalone:analysis-api-fir-standalone-base",
        ":analysis:analysis-api-fe10",
        ":analysis:decompiled:decompiler-to-psi",
        ":analysis:decompiled:decompiler-to-stubs",
        ":analysis:decompiled:decompiler-to-file-stubs",
        ":analysis:decompiled:decompiler-js",
        ":analysis:decompiled:decompiler-native",
        ":analysis:decompiled:light-classes-for-decompiled",
        ":prepare:analysis-api-test-framework",
        ":tools:ide-plugin-dependencies-validator"

if (buildProperties.isKotlinNativeEnabled) {
    include ":generators:analysis-api-generator:generator-kotlin-native",
            ":analysis:low-level-api-fir:low-level-api-fir-native",
            ":analysis:analysis-api-standalone:analysis-api-standalone-native"
}


if (!buildProperties.inJpsBuildIdeaSync) {
    // modules that we are currently cannot compile with jps
    include ":core:builtins",
            ":kotlin-stdlib-common",
            ":kotlin-stdlib",
            ":kotlin-dom-api-compat",
            ":kotlin-stdlib-js-ir-minimal-for-test",
            ":kotlin-stdlib-jdk7",
            ":kotlin-stdlib-jdk8",
            ":kotlin-stdlib:samples",
            ":kotlin-stdlib-jvm-minimal-for-test",
            ":tools:binary-compatibility-validator",
            ":tools:jdk-api-validator",
            ":tools:kotlin-stdlib-gen",

            ":kotlin-test",
            ":kotlin-test:kotlin-test-js-it",
            ":native:native.tests",
            ":native:native.tests:driver",
            ":native:native.tests:stress",
            ":native:native.tests:klib-ir-inliner",
            ":native:native.tests:klib-compatibility",
            ":native:native.tests:litmus-tests"

    project(':kotlin-stdlib-common').projectDir = "$rootDir/libraries/stdlib/common" as File
    project(':kotlin-stdlib').projectDir = "$rootDir/libraries/stdlib" as File
    project(':kotlin-dom-api-compat').projectDir = "$rootDir/libraries/kotlin-dom-api-compat" as File
    project(':kotlin-stdlib-js-ir-minimal-for-test').projectDir = "$rootDir/libraries/stdlib/js-ir-minimal-for-test" as File
    project(':kotlin-stdlib-jdk7').projectDir = "$rootDir/libraries/stdlib/jdk7" as File
    project(':kotlin-stdlib-jdk8').projectDir = "$rootDir/libraries/stdlib/jdk8" as File
    project(':kotlin-stdlib:samples').projectDir = "$rootDir/libraries/stdlib/samples" as File
    project(":kotlin-stdlib-jvm-minimal-for-test").projectDir = "$rootDir/libraries/stdlib/jvm-minimal-for-test" as File

    project(':tools').projectDir = "$rootDir/libraries/tools" as File
    project(':tools:binary-compatibility-validator').projectDir = "$rootDir/libraries/tools/binary-compatibility-validator" as File
    project(':tools:jdk-api-validator').projectDir = "$rootDir/libraries/tools/jdk-api-validator" as File
    project(':tools:kotlin-stdlib-gen').projectDir = "$rootDir/libraries/tools/kotlin-stdlib-gen" as File
    project(':tools:ide-plugin-dependencies-validator').projectDir = "$rootDir/libraries/tools/ide-plugin-dependencies-validator" as File

    project(':kotlin-test').projectDir = "$rootDir/libraries/kotlin.test" as File
    project(':kotlin-test:kotlin-test-js-it').projectDir = "$rootDir/libraries/kotlin.test/js/it" as File
}
include ":compiler:android-tests"

rootProject.name = "kotlin"

project(':kotlin-script-runtime').projectDir = "$rootDir/libraries/tools/script-runtime" as File
project(':kotlin-reflect').projectDir = "$rootDir/libraries/reflect" as File
project(':kotlin-reflect-api').projectDir = "$rootDir/libraries/reflect/api" as File
project(':kotlin-metadata').projectDir = "$rootDir/libraries/kotlinx-metadata" as File
project(':kotlin-metadata-jvm').projectDir = "$rootDir/libraries/kotlinx-metadata/jvm" as File
project(':kotlinx-metadata-klib').projectDir = "$rootDir/libraries/kotlinx-metadata/klib" as File
project(':kotlin-compiler').projectDir = "$rootDir/prepare/compiler" as File
project(':kotlin-compiler-embeddable').projectDir = "$rootDir/prepare/compiler-embeddable" as File
project(':kotlin-compiler-client-embeddable').projectDir = "$rootDir/prepare/compiler-client-embeddable" as File
project(':kotlin-preloader').projectDir = "$rootDir/compiler/preloader" as File
project(':kotlin-build-common').projectDir = "$rootDir/build-common" as File
project(':compiler:cli-common').projectDir = "$rootDir/compiler/cli/cli-common" as File
project(':compiler:cli-base').projectDir = "$rootDir/compiler/cli/cli-base" as File
project(':compiler:cli-js').projectDir = "$rootDir/compiler/cli/cli-js" as File
project(':kotlin-runner').projectDir = "$rootDir/compiler/cli/cli-runner" as File
project(':kotlin-daemon').projectDir = "$rootDir/compiler/daemon" as File
project(':daemon-common').projectDir = "$rootDir/compiler/daemon/daemon-common" as File
project(':kotlin-daemon-client').projectDir = "$rootDir/compiler/daemon/daemon-client" as File
project(':kotlin-daemon-tests').projectDir = "$rootDir/compiler/daemon/daemon-tests" as File
project(':kotlin-compiler-runner-unshaded').projectDir = "$rootDir/compiler/compiler-runner-unshaded" as File
project(':kotlin-compiler-runner').projectDir = "$rootDir/compiler/compiler-runner" as File
project(':kotlin-ant').projectDir = "$rootDir/ant" as File
project(':compiler:ir.tree').projectDir = "$rootDir/compiler/ir/ir.tree" as File
project(':compiler:ir.tree:tree-generator').projectDir = "$rootDir/compiler/ir/ir.tree/tree-generator" as File
project(':compiler:ir.psi2ir').projectDir = "$rootDir/compiler/ir/ir.psi2ir" as File
project(':compiler:ir.objcinterop').projectDir = "$rootDir/compiler/ir/ir.objcinterop" as File
project(':compiler:ir.backend.common').projectDir = "$rootDir/compiler/ir/backend.common" as File
project(':compiler:ir.backend.native').projectDir = "$rootDir/compiler/ir/backend.native" as File
project(':compiler:ir.actualization').projectDir = "$rootDir/compiler/ir/ir.actualization" as File
project(':compiler:ir.inline').projectDir = "$rootDir/compiler/ir/ir.inline" as File
project(':compiler:backend.js').projectDir = "$rootDir/compiler/ir/backend.js" as File
project(':compiler:backend.wasm').projectDir = "$rootDir/compiler/ir/backend.wasm" as File
project(':compiler:backend.jvm').projectDir = "$rootDir/compiler/ir/backend.jvm" as File
project(':compiler:backend.jvm.lower').projectDir = "$rootDir/compiler/ir/backend.jvm/lower" as File
project(':compiler:backend.jvm.codegen').projectDir = "$rootDir/compiler/ir/backend.jvm/codegen" as File
project(':compiler:backend.jvm.entrypoint').projectDir = "$rootDir/compiler/ir/backend.jvm/entrypoint" as File
project(':compiler:ir.serialization.common').projectDir = "$rootDir/compiler/ir/serialization.common" as File
project(':compiler:ir.serialization.jvm').projectDir = "$rootDir/compiler/ir/serialization.jvm" as File
project(':compiler:ir.serialization.js').projectDir = "$rootDir/compiler/ir/serialization.js" as File
project(':compiler:ir.serialization.native').projectDir = "$rootDir/compiler/ir/serialization.native" as File
project(':compiler:ir.interpreter').projectDir = "$rootDir/compiler/ir/ir.interpreter" as File
project(':kotlin-util-io').projectDir = "$rootDir/compiler/util-io" as File
project(':kotlin-util-klib').projectDir = "$rootDir/compiler/util-klib" as File
project(':kotlin-util-klib-metadata').projectDir = "$rootDir/compiler/util-klib-metadata" as File
project(':kotlin-util-klib-abi').projectDir = "$rootDir/compiler/util-klib-abi" as File
project(':native:kotlin-native-utils').projectDir = "$rootDir/native/utils" as File
project(':native:frontend.native').projectDir = "$rootDir/native/frontend" as File
project(':native:kotlin-klib-commonizer').projectDir = "$rootDir/native/commonizer" as File
project(":native:kotlin-klib-commonizer-api").projectDir = "$rootDir/native/commonizer-api" as File
project(':native:kotlin-klib-commonizer-embeddable').projectDir = "$rootDir/native/commonizer-embeddable" as File
project(':native:objcexport-header-generator-k1').projectDir = "$rootDir/native/objcexport-header-generator/impl/k1" as File
project(':native:objcexport-header-generator-analysis-api').projectDir = "$rootDir/native/objcexport-header-generator/impl/analysis-api" as File
project(':native:objcexport-header-generator:testLibraryA').projectDir = "$rootDir/native/objcexport-header-generator/testDependencies/testLibraryA" as File
project(':native:objcexport-header-generator:testLibraryB').projectDir = "$rootDir/native/objcexport-header-generator/testDependencies/testLibraryB" as File
project(':native:objcexport-header-generator:testLibraryC').projectDir = "$rootDir/native/objcexport-header-generator/testDependencies/testLibraryC" as File
project(':native:objcexport-header-generator:testInternalLibrary').projectDir = "$rootDir/native/objcexport-header-generator/testDependencies/testInternalLibrary" as File
project(':native:objcexport-header-generator:testExtensionsLibrary').projectDir = "$rootDir/native/objcexport-header-generator/testDependencies/testExtensionsLibrary" as File
project(':plugins:android-extensions-compiler').projectDir = "$rootDir/plugins/android-extensions/android-extensions-compiler" as File
project(':kotlin-android-extensions').projectDir = "$rootDir/prepare/android-extensions-compiler-gradle" as File
project(':kotlin-parcelize-compiler').projectDir = "$rootDir/prepare/parcelize-compiler-gradle" as File
project(':kotlin-android-extensions-runtime').projectDir = "$rootDir/plugins/android-extensions/android-extensions-runtime" as File

project(':kotlin-allopen-compiler-plugin').projectDir = "$rootDir/plugins/allopen" as File
project(":kotlin-allopen-compiler-plugin.embeddable").projectDir = "$rootDir/plugins/allopen/allopen.embeddable" as File
project(':kotlin-allopen-compiler-plugin.common').projectDir = "$rootDir/plugins/allopen/allopen.common" as File
project(':kotlin-allopen-compiler-plugin.k1').projectDir = "$rootDir/plugins/allopen/allopen.k1" as File
project(':kotlin-allopen-compiler-plugin.k2').projectDir = "$rootDir/plugins/allopen/allopen.k2" as File
project(':kotlin-allopen-compiler-plugin.cli').projectDir = "$rootDir/plugins/allopen/allopen.cli" as File

project(':kotlin-lombok-compiler-plugin').projectDir = "$rootDir/plugins/lombok" as File
project(':kotlin-lombok-compiler-plugin.embeddable').projectDir = "$rootDir/plugins/lombok/lombok.embeddable" as File
project(':kotlin-lombok-compiler-plugin.cli').projectDir = "$rootDir/plugins/lombok/lombok.cli" as File
project(':kotlin-lombok-compiler-plugin.k1').projectDir = "$rootDir/plugins/lombok/lombok.k1" as File
project(':kotlin-lombok-compiler-plugin.k2').projectDir = "$rootDir/plugins/lombok/lombok.k2" as File
project(':kotlin-lombok-compiler-plugin.common').projectDir = "$rootDir/plugins/lombok/lombok.common" as File

project(':kotlin-noarg-compiler-plugin').projectDir = "$rootDir/plugins/noarg" as File
project(':kotlin-noarg-compiler-plugin.embeddable').projectDir = "$rootDir/plugins/noarg/noarg.embeddable" as File
project(':kotlin-noarg-compiler-plugin.common').projectDir = "$rootDir/plugins/noarg/noarg.common" as File
project(':kotlin-noarg-compiler-plugin.k1').projectDir = "$rootDir/plugins/noarg/noarg.k1" as File
project(':kotlin-noarg-compiler-plugin.k2').projectDir = "$rootDir/plugins/noarg/noarg.k2" as File
project(':kotlin-noarg-compiler-plugin.backend').projectDir = "$rootDir/plugins/noarg/noarg.backend" as File
project(':kotlin-noarg-compiler-plugin.cli').projectDir = "$rootDir/plugins/noarg/noarg.cli" as File

project(':kotlin-power-assert-compiler-plugin').projectDir = "$rootDir/plugins/power-assert" as File
project(':kotlin-power-assert-compiler-plugin.embeddable').projectDir = "$rootDir/plugins/power-assert/power-assert.embeddable" as File
project(':kotlin-power-assert-compiler-plugin.backend').projectDir = "$rootDir/plugins/power-assert/power-assert.backend" as File
project(':kotlin-power-assert-compiler-plugin.cli').projectDir = "$rootDir/plugins/power-assert/power-assert.cli" as File

project(':kotlin-sam-with-receiver-compiler-plugin').projectDir = "$rootDir/plugins/sam-with-receiver" as File
project(':kotlin-sam-with-receiver-compiler-plugin.embeddable').projectDir = "$rootDir/plugins/sam-with-receiver/sam-with-receiver.embeddable" as File
project(':kotlin-sam-with-receiver-compiler-plugin.common').projectDir = "$rootDir/plugins/sam-with-receiver/sam-with-receiver.common" as File
project(':kotlin-sam-with-receiver-compiler-plugin.k1').projectDir = "$rootDir/plugins/sam-with-receiver/sam-with-receiver.k1" as File
project(':kotlin-sam-with-receiver-compiler-plugin.k2').projectDir = "$rootDir/plugins/sam-with-receiver/sam-with-receiver.k2" as File
project(':kotlin-sam-with-receiver-compiler-plugin.cli').projectDir = "$rootDir/plugins/sam-with-receiver/sam-with-receiver.cli" as File

project(':kotlin-assignment-compiler-plugin').projectDir = "$rootDir/plugins/assign-plugin" as File
project(':kotlin-assignment-compiler-plugin.common').projectDir = "$rootDir/plugins/assign-plugin/assign-plugin.common" as File
project(':kotlin-assignment-compiler-plugin.k1').projectDir = "$rootDir/plugins/assign-plugin/assign-plugin.k1" as File
project(':kotlin-assignment-compiler-plugin.k2').projectDir = "$rootDir/plugins/assign-plugin/assign-plugin.k2" as File
project(':kotlin-assignment-compiler-plugin.cli').projectDir = "$rootDir/plugins/assign-plugin/assign-plugin.cli" as File
project(':kotlin-assignment-compiler-plugin.embeddable').projectDir = "$rootDir/plugins/assign-plugin/assign-plugin.embeddable" as File

project(':tools:kotlinp').projectDir = "$rootDir/libraries/tools/kotlinp" as File
project(':tools:kotlinp-jvm').projectDir = "$rootDir/libraries/tools/kotlinp/jvm" as File
project(':tools:kotlinp-klib').projectDir = "$rootDir/libraries/tools/kotlinp/klib" as File
project(":kotlin-build-tools-enum-compat").projectDir = "$rootDir/libraries/tools/kotlin-build-tools-enum-compat" as File
project(':kotlin-gradle-compiler-types').projectDir = "$rootDir/libraries/tools/kotlin-gradle-compiler-types" as File
project(':kotlin-gradle-plugin-api').projectDir = "$rootDir/libraries/tools/kotlin-gradle-plugin-api" as File
project(':kotlin-gradle-plugin-annotations').projectDir = "$rootDir/libraries/tools/kotlin-gradle-plugin-annotations" as File
project(':kotlin-gradle-plugin-idea').projectDir = "$rootDir/libraries/tools/kotlin-gradle-plugin-idea" as File
project(':kotlin-gradle-plugin-idea-proto').projectDir = "$rootDir/libraries/tools/kotlin-gradle-plugin-idea-proto" as File
project(':kotlin-gradle-plugin-idea-for-compatibility-tests').projectDir = "$rootDir/libraries/tools/kotlin-gradle-plugin-idea-for-compatibility-tests" as File
project(':kotlin-gradle-plugin-dsl-codegen').projectDir = "$rootDir/libraries/tools/kotlin-gradle-plugin-dsl-codegen" as File
project(':kotlin-gradle-plugin-npm-versions-codegen').projectDir = "$rootDir/libraries/tools/kotlin-gradle-plugin-npm-versions-codegen" as File
project(':kotlin-gradle-statistics').projectDir = "$rootDir/libraries/tools/kotlin-gradle-statistics" as File
project(':kotlin-gradle-build-metrics').projectDir = "$rootDir/libraries/tools/kotlin-gradle-build-metrics" as File
project(':kotlin-gradle-plugin').projectDir = "$rootDir/libraries/tools/kotlin-gradle-plugin" as File
project(':kotlin-gradle-plugin-tcs-android').projectDir = "$rootDir/libraries/tools/kotlin-gradle-plugin-tcs-android" as File
project(':kotlin-gradle-plugin-model').projectDir = "$rootDir/libraries/tools/kotlin-gradle-plugin-model" as File
project(':kotlin-gradle-plugin-test-utils-embeddable').projectDir = "$rootDir/libraries/tools/kotlin-gradle-plugin-test-utils-embeddable" as File
project(':kotlin-gradle-plugin-integration-tests').projectDir = "$rootDir/libraries/tools/kotlin-gradle-plugin-integration-tests" as File
project(':kotlin-gradle-plugins-bom').projectDir = "$rootDir/libraries/tools/kotlin-gradle-plugins-bom" as File
project(':kotlin-privacy-manifests-plugin').projectDir = "$rootDir/libraries/tools/kotlin-privacy-manifests-plugin" as File
project(':gradle:android-test-fixes').projectDir = "$rootDir/libraries/tools/gradle/android-test-fixes" as File
project(':gradle:documentation').projectDir = "$rootDir/libraries/tools/gradle/documentation" as File
project(':gradle:gradle-warnings-detector').projectDir = "$rootDir/libraries/tools/gradle/gradle-warnings-detector" as File
project(':gradle:kotlin-compiler-args-properties').projectDir = "$rootDir/libraries/tools/gradle/kotlin-compiler-args-properties" as File
project(":gradle:regression-benchmark-templates").projectDir = "$rootDir/libraries/tools/gradle/regression-benchmark-templates" as File
project(":gradle:regression-benchmarks").projectDir = "$rootDir/libraries/tools/gradle/regression-benchmarks" as File
project(':kotlin-tooling-metadata').projectDir = "$rootDir/libraries/tools/kotlin-tooling-metadata" as File
project(':kotlin-tooling-core').projectDir = "$rootDir/libraries/tools/kotlin-tooling-core" as File
project(':compose-compiler-gradle-plugin').projectDir = "$rootDir/libraries/tools/kotlin-compose-compiler" as File
project(':kotlin-allopen').projectDir = "$rootDir/libraries/tools/kotlin-allopen" as File
project(':kotlin-noarg').projectDir = "$rootDir/libraries/tools/kotlin-noarg" as File
project(':kotlin-power-assert').projectDir = "$rootDir/libraries/tools/kotlin-power-assert" as File
project(':kotlin-sam-with-receiver').projectDir = "$rootDir/libraries/tools/kotlin-sam-with-receiver" as File
project(':kotlin-assignment').projectDir = "$rootDir/libraries/tools/kotlin-assignment" as File
project(':kotlin-lombok').projectDir = "$rootDir/libraries/tools/kotlin-lombok" as File
project(':kotlin-gradle-subplugin-example').projectDir = "$rootDir/libraries/examples/kotlin-gradle-subplugin-example" as File
project(':examples').projectDir = "$rootDir/libraries/examples" as File
project(':examples:annotation-processor-example').projectDir = "$rootDir/libraries/examples/annotation-processor-example" as File
project(':kotlin-annotation-processing-embeddable').projectDir = "$rootDir/plugins/kapt3/kotlin-annotation-processing-embeddable" as File
project(':kotlin-daemon-embeddable').projectDir = "$rootDir/prepare/kotlin-daemon-embeddable" as File
project(':kotlin-annotation-processing-cli').projectDir = "$rootDir/plugins/kapt3/kapt3-cli" as File
project(':kotlin-annotation-processing-base').projectDir = "$rootDir/plugins/kapt3/kapt3-base" as File
project(':kotlin-annotation-processing-runtime').projectDir = "$rootDir/plugins/kapt3/kapt3-runtime" as File
project(':kotlin-annotation-processing').projectDir = "$rootDir/plugins/kapt3/kapt3-compiler" as File
project(':kotlin-annotations-jvm').projectDir = "$rootDir/libraries/tools/kotlin-annotations-jvm" as File
project(':kotlin-scripting-common').projectDir = "$rootDir/libraries/scripting/common" as File
project(':kotlin-scripting-jvm').projectDir = "$rootDir/libraries/scripting/jvm" as File
project(':kotlin-scripting-jvm-host-unshaded').projectDir = "$rootDir/libraries/scripting/jvm-host" as File
project(':kotlin-scripting-jvm-host-test').projectDir = "$rootDir/libraries/scripting/jvm-host-test" as File
project(':kotlin-scripting-jvm-host').projectDir = "$rootDir/libraries/scripting/jvm-host-embeddable" as File
project(':kotlin-scripting-dependencies').projectDir = "$rootDir/libraries/scripting/dependencies" as File
project(':kotlin-scripting-dependencies-maven').projectDir = "$rootDir/libraries/scripting/dependencies-maven" as File
project(':kotlin-scripting-dependencies-maven-all').projectDir = "$rootDir/libraries/scripting/dependencies-maven-all" as File
project(':kotlin-scripting-jsr223-unshaded').projectDir = "$rootDir/libraries/scripting/jsr223" as File
project(':kotlin-scripting-jsr223-test').projectDir = "$rootDir/libraries/scripting/jsr223-test" as File
project(':kotlin-scripting-jsr223').projectDir = "$rootDir/libraries/scripting/jsr223-embeddable" as File
project(':kotlin-scripting-intellij').projectDir = "$rootDir/libraries/scripting/intellij" as File
project(':kotlin-scripting-compiler').projectDir = "$rootDir/plugins/scripting/scripting-compiler" as File
project(':kotlin-scripting-compiler-embeddable').projectDir = "$rootDir/plugins/scripting/scripting-compiler-embeddable" as File
project(':kotlin-scripting-compiler-impl').projectDir = "$rootDir/plugins/scripting/scripting-compiler-impl" as File
project(':kotlin-scripting-compiler-impl-embeddable').projectDir = "$rootDir/plugins/scripting/scripting-compiler-impl-embeddable" as File
project(':kotlin-main-kts').projectDir = "$rootDir/libraries/tools/kotlin-main-kts" as File
project(':kotlin-main-kts-test').projectDir = "$rootDir/libraries/tools/kotlin-main-kts-test" as File
project(':examples:scripting-jvm-simple-script').projectDir = "$rootDir/libraries/examples/scripting/jvm-simple-script/script" as File
project(':examples:scripting-jvm-simple-script-host').projectDir = "$rootDir/libraries/examples/scripting/jvm-simple-script/host" as File
project(':examples:scripting-jvm-maven-deps').projectDir = "$rootDir/libraries/examples/scripting/jvm-maven-deps/script" as File
project(':examples:scripting-jvm-maven-deps-host').projectDir = "$rootDir/libraries/examples/scripting/jvm-maven-deps/host" as File
project(':examples:scripting-jvm-embeddable-host').projectDir = "$rootDir/libraries/examples/scripting/jvm-embeddable-host" as File
project(':pill').projectDir = "$rootDir/plugins/pill" as File
project(':pill:pill-importer').projectDir = "$rootDir/plugins/pill/pill-importer" as File
project(':pill:generate-all-tests').projectDir = "$rootDir/plugins/pill/generate-all-tests" as File
project(':kotlin-imports-dumper-compiler-plugin').projectDir = "$rootDir/plugins/imports-dumper" as File
project(':libraries:kotlin-prepush-hook').projectDir = "$rootDir/libraries/tools/kotlin-prepush-hook" as File
project(':plugins:jvm-abi-gen').projectDir = "$rootDir/plugins/jvm-abi-gen" as File
project(':plugins:jvm-abi-gen-embeddable').projectDir = "$rootDir/plugins/jvm-abi-gen/embeddable" as File

project(':js:js.tests').projectDir = "$rootDir/js/js.tests" as File
project(':js:js.tests:klib-compatibility').projectDir = "$rootDir/js/js.tests/klib-compatibility" as File

project(':kotlinx-serialization-compiler-plugin').projectDir = "$rootDir/plugins/kotlinx-serialization" as File
project(':kotlinx-serialization-compiler-plugin.embeddable').projectDir = "$rootDir/plugins/kotlinx-serialization/kotlinx-serialization.embeddable" as File
project(':kotlinx-serialization-compiler-plugin.cli').projectDir = "$rootDir/plugins/kotlinx-serialization/kotlinx-serialization.cli" as File
project(':kotlinx-serialization-compiler-plugin.backend').projectDir = "$rootDir/plugins/kotlinx-serialization/kotlinx-serialization.backend" as File
project(':kotlinx-serialization-compiler-plugin.k1').projectDir = "$rootDir/plugins/kotlinx-serialization/kotlinx-serialization.k1" as File
project(':kotlinx-serialization-compiler-plugin.k2').projectDir = "$rootDir/plugins/kotlinx-serialization/kotlinx-serialization.k2" as File
project(':kotlinx-serialization-compiler-plugin.common').projectDir = "$rootDir/plugins/kotlinx-serialization/kotlinx-serialization.common" as File
project(':kotlin-serialization').projectDir = file("$rootDir/libraries/tools/kotlin-serialization")
project(':kotlin-serialization-unshaded').projectDir = file("$rootDir/libraries/tools/kotlin-serialization-unshaded")

project(':kotlin-atomicfu-compiler-plugin').projectDir = file("$rootDir/plugins/atomicfu/atomicfu-compiler")
project(':kotlin-atomicfu-compiler-plugin-embeddable').projectDir = file("$rootDir/plugins/atomicfu/atomicfu-compiler-embeddable")
project(':kotlinx-atomicfu-runtime').projectDir = file("$rootDir/plugins/atomicfu/atomicfu-runtime")
project(':atomicfu').projectDir = file("$rootDir/libraries/tools/atomicfu")

if (!buildProperties.inJpsBuildIdeaSync) {
    project(':plugins:compose-compiler-plugin').projectDir = file("$rootDir/plugins/compose")
    project(':plugins:compose-compiler-plugin:compiler').projectDir = file("$rootDir/plugins/compose/compiler")
    project(':plugins:compose-compiler-plugin:compiler-hosted').projectDir = file("$rootDir/plugins/compose/compiler-hosted")
    project(':plugins:compose-compiler-plugin:compiler-hosted:integration-tests').projectDir = file("$rootDir/plugins/compose/compiler-hosted/integration-tests")
    project(':plugins:compose-compiler-plugin:compiler-hosted:integration-tests:protobuf-test-classes').projectDir =
            file("$rootDir/plugins/compose/compiler-hosted/integration-tests/protobuf-test-classes")

    if (buildProperties.inIdeaSync) {
        project(':plugins:compose-compiler-plugin:compiler-hosted:runtime-tests').projectDir = file("$rootDir/plugins/compose/compiler-hosted/runtime-tests")
    }
}

project(':kotlin-scripting-ide-services-unshaded').projectDir = "$rootDir/plugins/scripting/scripting-ide-services" as File
project(':kotlin-scripting-ide-services-test').projectDir = "$rootDir/plugins/scripting/scripting-ide-services-test" as File
project(':kotlin-scripting-ide-services').projectDir = "$rootDir/plugins/scripting/scripting-ide-services-embeddable" as File
project(':kotlin-scripting-ide-common').projectDir = "$rootDir/plugins/scripting/scripting-ide-common" as File
project(':kotlin-scripting-compiler').projectDir = "$rootDir/plugins/scripting/scripting-compiler" as File
project(':kotlin-scripting-compiler-impl').projectDir = "$rootDir/plugins/scripting/scripting-compiler-impl" as File

// Uncomment to use locally built protobuf-relocated
// includeBuild("dependencies/protobuf")
if (buildProperties.isKotlinNativeEnabled) {
    includeBuild("kotlin-native/build-tools") {
        name = "native-build-tools"
    }
    include ':kotlin-native:dependencies'
    include ':kotlin-native:endorsedLibraries:kotlinx.cli'
    include ':kotlin-native:Interop:StubGenerator'
    include ':kotlin-native:Interop:StubGeneratorConsistencyCheck'
    include ':kotlin-native:backend.native'
    project(':kotlin-native:backend.native').projectDir = "$rootDir/kotlin-native/backend.native/compiler/ir/backend.native" as File
    include ':kotlin-native:Interop:Runtime'
    include ':kotlin-native:Interop:Indexer'
    include ':kotlin-native:Interop:JsRuntime'
    include ':kotlin-native:utilities:cli-runner'
    include ':kotlin-native:klib'
    include ':kotlin-native:common'
    include ':kotlin-native:common:env'
    include ':kotlin-native:common:files'
    include ':kotlin-native:runtime'
    include ':kotlin-native:libllvmext'
    include ':kotlin-native:llvmDebugInfoC'
    include ':kotlin-native:utilities'
    include ':kotlin-native:tools:kdumputil'
    include ':kotlin-native:platformLibs'
    include ':kotlin-native:libclangext'
    include ':kotlin-native:llvmInterop'
    include ':kotlin-native:libclangInterop'
    include ':kotlin-native:backend.native:tests'
    project(':kotlin-native:backend.native:tests').projectDir = "$rootDir/kotlin-native/backend.native/tests" as File
    include ':kotlin-native:prepare:kotlin-native-compiler-embeddable'
    include ':native:kotlin-test-native-xctest'
    include ':native:cli-native'
    include ':native:native.tests:cli-tests'
}