plugins {
    id("gradlebuild.distribution.api-java")
}

description = "A set of generic services and utilities specific for Groovy."

dependencies {
    api(project(":base-services"))
    api(projects.stdlibJavaExtensions)

    api(libs.jsr305)
    api(libs.groovy)
    api(libs.guava)

    testImplementation(testFixtures(project(":core")))

                    if (sourceFile.name in filesWithUnsupportedAnnotations) {
                        // This is a hack.
                        //
                        // qdox doesn't understand annotations placed in generic type parameters
                        // The only place we use this is with Nullable, so this hackily removes the annotation when
                        // the source file is processed by qdox.
                        //

private
fun KType.toDataTypeRef(): DataTypeRef? = when {
    // isMarkedNullable -> TODO: support nullable types
    arguments.isNotEmpty() -> null // TODO: support for some particular generic types
    else -> when (val classifier = classifier) {
        null -> null
        else -> classifier.toDataTypeRef()
    }

     * Workaround: use Java reflection to determine the supertypes.
     * TODO: Either fix Kotlin metadata in decorated classes or introduce generic utilities
     */
    private
    fun typeHierarchyViaJavaReflection(kClass: KClass<*>): Iterable<KClass<*>> =
        Traverser.forGraph<Class<*>> { listOfNotNull(it.superclass) + it.interfaces }

                *23*
                *42*
                """
            )
        )
    }

    @Test
    @LeaksFileHandles("Kotlin Compiler Daemon working directory")
    fun `given generic extension types they can be accessed and configured`() {

        withDefaultSettingsIn("buildSrc")

        withFile(
            "buildSrc/build.gradle.kts",
            """

            plugins {

        dynamicObjectMockFor(existing, absent).let { dynamicObject ->
            val serviceRegistryMock = mock<ServiceRegistry> {
                onGeneric { get<DynamicLookupRoutine>() } doReturn DefaultDynamicLookupRoutine()
            }
            val gradleInternalMock = mock<GradleInternal>(name = "gradleInternal") {

    native --> software

    enterprise["enterprise module"]
    style enterprise stroke:#1abc9c,fill:#b1f4e7,stroke-width:2px,color:#000;
```

## Platforms

### Core automation platform

This is a general-purpose automation platform which takes care of the efficient definition and execution of work, such as tasks.
This platform is agnostic to what exactly the purpose of the work is.

import org.gradle.internal.declarativedsl.mappingToJvm.RuntimeFunctionResolver
import org.gradle.internal.declarativedsl.mappingToJvm.RuntimePropertyResolver


/**
 * Provides declarative schema building features for a general-purpose Gradle DSL.
 *
 * The features are:
 * * importing properties using the [org.gradle.api.provider.Property] API,
 * * importing types from functions that return or configure custom types.
 *

# Gradle Javadoc Style Guide

## 1.1 Formatting

### 1.1.1 General form

The basic formatting of Javadoc blocks is as seen in this example:

```java
/**
 * Returns an Image object that can then be painted on the screen.
 * <p>
 * The url argument must specify an absolute {@link URL}. 
 * The name argument is a specifier that is relative to the url argument.
 * This method always returns immediately, whether or not the image exists. 
 *

IntelliJ automatically hides stacktrace elements from the `org.gradle` package, which makes running/debugging tests more difficult. You can disable this behavior by changing IntelliJ Preferences under Editor -> General -> Console. In the "Fold lines that contain" section, remove the `org.gradle` entry.