}

description = "Common shared classes used by the Declarative DSL"

tasks.withType<KotlinCompile>().configureEach {
    compilerOptions {
        apiVersion.set(KotlinVersion.KOTLIN_1_9)
        languageVersion.set(KotlinVersion.KOTLIN_1_9)
    }
}

dependencies {
    api(project(":declarative-dsl-tooling-models"))

    api(libs.kotlinCompilerEmbeddable)
    api(libs.kotlinStdlib)

                runtimeClassPathArtifactCollection.set(configurations["runtimeClasspath"].incoming.artifacts)
                sourceCodeOutputDir.set(it)
                metadataOutputDir.set(accessorsMetadata)
                compiledPluginsBlocksDir.set(compiledPluginsBlocks)
                @Suppress("DEPRECATION")
                strict.set(
                    providers

    }

    @Internal
    protected
    fun getContributorsFromPullRequests(): Set<GitHubUser> {
        if (!milestone.isPresent) {
            throw IllegalStateException("Milestone not set: please rerun the task with `--milestone <milestone>`")
        }
        val prs: MutableList<GitHubPullRequest> = mutableListOf()
        (1..10).forEach { page ->

/**
 * Test Fixtures Plugin.
 *
 * Configures the Project as a test fixtures producer if `src/testFixtures` is a directory:
 * - adds a new `testFixtures` source set which should contain utilities/fixtures to assist in unit testing
 *   classes from the main source set,
 * - the test fixtures are automatically made available to the test classpath.
 *

        override val defaultImports: Set<FqName> = setOf()

        private
        fun readResolve(): Any = Empty
    }
}


@Serializable
@SerialName("data")
data class DefaultDataClass(
    override val name: FqName,
    override val supertypes: Set<FqName>,
    override val properties: List<DataProperty>,

import java.io.File
import java.io.StringReader
import java.net.URLClassLoader


/**
 * Provides `@since` javadoc tag value from sources.
 */
class FunctionSinceRepository(classPath: Set<File>, sourcePath: Set<File>) : AutoCloseable {

    // https://github.com/paul-hammant/qdox/issues/182
    private
    val filesWithUnsupportedAnnotations = listOf(
        "Transformer.java",
        "Provider.java",

    val minified = Attribute.of("minified", Boolean::class.javaObjectType)
}


class JarAnalyzer(
    private val shadowPackage: String,
    private val keepPackages: Set<String>,
    private val unshadedPackages: Set<String>,
    private val ignorePackages: Set<String>
) {

    fun analyze(jarFile: File, classesDir: File, manifestFile: File, buildReceipt: File): ClassGraph {
        val classGraph = classGraph()

private
class ClassLoaderClassPathCache {

    private
    val cachedClassPaths = hashMapOf<ClassLoader, Set<File>>()

    fun of(classLoader: ClassLoader): Set<File> =
        cachedClassPaths.getOrPut(classLoader) {
            classPathOf(classLoader)
        }

    private
    fun classPathOf(classLoader: ClassLoader): Set<File> {
        val classPathFiles = mutableSetOf<File>()

        object : ClassLoaderVisitor() {

@CacheableTransform
abstract class Minify : TransformAction<Minify.Parameters> {

    interface Parameters : TransformParameters {
        @get:Input
        var keepClassesByArtifact: Map<String, Set<String>>
    }

    @get:PathSensitive(PathSensitivity.NAME_ONLY)
    @get:InputArtifact
    abstract val artifact: Provider<FileSystemLocation>

    override fun transform(outputs: TransformOutputs) {

    val inlineFunctions: MutableSet<String> = HashSet()
    val internalFunctions: MutableSet<String> = HashSet()

    override fun writeClass(classMember: ClassMember, methods: Set<MethodMember>, fields: Set<FieldMember>, innerClasses: Set<InnerClassMember>) {
        classMember.annotations.firstOrNull {
            it.name == kotlinMetadataAnnotationSignature
        }?.let {