data class PluginEntry(val pluginId: String, val implementationClass: String)


fun pluginEntriesFrom(jar: File): List<PluginEntry> = try {
    JarFile(jar, false).use { jarFile ->
        jarFile.entries().asSequence().filter {
            isGradlePluginPropertiesFile(it)
        }.map { pluginEntry ->
            val pluginProperties = jarFile.getInputStream(pluginEntry).use { Properties().apply { load(it) } }

private
fun kotlinDslApiExtensionsDeclarationsFor(
    api: ApiTypeProvider,
    sinceSupplier: (String) -> String?,
    apiSpec: ApiSpec
): Sequence<KotlinExtensionFunction> =

    api.allTypes()
        .filter { type -> type.isPublic && apiSpec.isApi(type.sourceName) }
        .flatMap { type -> kotlinExtensionFunctionsFor(type, sinceSupplier) }
        .distinctBy(::signatureKey)


private

                }
            }
            targets {
                all {
                    testTask.configure {
                        testClassesDirs += sharedArchTestClasses.filter { it.isDirectory }
                        classpath += sourceSets.main.get().output.classesDirs
                        systemProperty("package.cycle.exclude.patterns", packageCyclesExtension.excludePatterns.get().joinToString(","))

                }
        }
        return versionsToIncubating
    }

    private
    fun CompilationUnit.findAllIncubating() =
        findAll(Node::class.java).filter { it.isIncubating }

    private
    val Node.isIncubating: Boolean
        get() = (this as? NodeWithAnnotations<*>)?.annotations?.any { it.nameAsString == "Incubating" } ?: false

    private

        "-PflakyTests=${determineFlakyTestStrategy(stage)}",
        extraParameters,
        parallelizationMethod.extraBuildParameters
    ).filter { it.isNotBlank() }.joinToString(separator = " ")

    if (parallelizationMethod is ParallelizationMethod.TeamCityParallelTests) {
        tcParallelTests(parallelizationMethod.numberOfBatches)
    }

    features {

"""
        if (performanceTestProject.performanceTests.any { it.testProjects.isNotEmpty() }) {
            val dependencyBuildIds = performanceTestProject.performanceTests
                .filter { it.testProjects.isNotEmpty() }
                .joinToString(",") { "%dep.${it.id}.env.BUILD_ID%" }

    ignores (path) {
        return this._test(path, this._ignoreCache, false).ignored
    }

    createFilter () {
        return path => !this.ignores(path)
    }

    filter (paths) {
        return makeArray(paths).filter(this.createFilter())
    }

    // @returns {TestResult}
    test (path) {
        return this._test(path, this._testCache, true)
    }
}

                    """
                    @file:Incubating
                    package com.example

                    import org.gradle.api.Incubating

                    ${annotatedKotlinMembers.lineSequence().filter { !it.contains("Incubating") }.joinToString("\n")}

                    /** @since 2.0 */
                    const val cathedral = "cathedral"
                    """
                )
            }