which combines profile activation+injection and inheritance assembly from parents,

   * known limitations are notably that:

     1. plugin goal execution in a child is usually simply appended (at end): you can't try to insert in the middle of pre-existing inherited executions,

     2. append happens at plugin level first, then goal level, independently from phases.

        val subProjectFolders = subprojectRoots.map { it.listFiles(File::isDirectory).asList() }.flatten().filter { dir ->
            // filter out the directories that have only a `build` subdirectory - this usually happens after branch switching
            dir.listFiles { _: File, name: String -> name != "build" }!!.isNotEmpty()
        }
        assertFalse(subProjectFolders.isEmpty())
        return subProjectFolders
    }

    {{{https://cwiki.apache.org/confluence/display/MAVENOLD/Reporting+Encoding+Configuration}reporting output files encoding}}
    (defaults to <<<UTF-8>>> since Maven 4.0.0, no default value was provided in Maven 3.x, plugins usually defaulting
    to <<<UTF-8>>>)

    []

            it is JavaCompile || it is GroovyCompile
        }
        dependsOn(compileTasks)
    }

    tasks.register("compileAllProduction") {
        description = "Compile all production source code, usually only main and testFixtures."
        val compileTasks = project.tasks.matching {
            // Currently, we compile everything since the Groovy compiler is not deterministic enough.

| 7  | `@apiSpec`    | Adds a “API Requirements” heading                                              | A description that applies equally to all valid implementations of the method, including preconditions, postconditions, etc                                                                                        |

        val result = mutableMapOf<KaTypeParameterSymbol, KaType>()

        for ((index, typeParameter) in typeParameters.withIndex()) {
            // After resolution all type arguments should be usual types (not FirPlaceholderProjection)
            val typeArgument = typeArguments[index]
            if (typeArgument !is FirTypeProjectionWithVariance || typeArgument.variance != Variance.INVARIANT) return emptyMap()

    }

    private val FirPropertyAccessExpression.correspondingNameReference: KtNameReferenceExpression?
        get() {
            val nameReference = when (val sourcePsi = psi) {
                // usual `foo.bar.baz` case
                is KtDotQualifiedExpression -> sourcePsi.selectorExpression

                // short `foo` case, or implicit invoke call like `foo.bar.baz()`
                else -> sourcePsi

        mavenCentral()
        gradlePluginPortal()
    }
}

apply(from = "../gradle/shared-with-buildSrc/mirrors.settings.gradle.kts")

// Utilities for updating the build itself which are not part of the usual build process
include("build-update-utils")

// Collection of plugins for the root build to configure lifecycle, reporting and IDE integration
include("root-build")

// Shared information about external modules

- [`KT-56624`](https://youtrack.jetbrains.com/issue/KT-56624) "Unresolved reference" with import alias and enum constructor call
- [`KT-54726`](https://youtrack.jetbrains.com/issue/KT-54726) K1: StackOverflowError on mutually recursive typealiases
- [`KT-35134`](https://youtrack.jetbrains.com/issue/KT-35134) False negative INCOMPATIBLE_TYPES, EQUALITY_NOT_APPLICABLE when comparing smartcast value to Boolean

        val signature = value.implMethodSignature
        val paramTypes: Array<Type> = getArgumentTypes(signature)

        // Treat all parameters equally, regardless of whether they are implicit captured parameters or the lambda signature ones.
        // If any of them is of an unsupported type, a build that runs from the serialized state won't be able to provide an instance anyway.