application {
                   mainClass = 'Main'
                }
                dependencies {
                    implementation 'org.test:lib:1.0'
                }
            """
            file('src/main/java/Main.java') << """
                class Main { public static void main(String[] args) {
                    Lib.main();
                } }
            """
        }
    }

            ${mavenCentralRepository()}

            dependencies {
                implementation(localGroovy())
                testImplementation("junit:junit:4.13")
            }
        """
        file("src/main/groovy/Thing.groovy") << """
            class Thing {}
        """
        file("src/test/groovy/ThingTest.groovy") << """
            import org.junit.*
            class ThingTest {

    types = listOf(Abc::class, C::class, D::class),
    externalFunctions = listOf(::newD),
    defaultImports = listOf(DefaultFqName("com.example", "newD"))
)


object SimpleAnalysisDemo {
    @JvmStatic
    fun main(args: Array<String>) {
        printResolutionResults(
            schema.resolve(
                """
                    val myB = b()

                    a = myB
                    val myD = newD("shared")

            plugins { `kotlin-dsl` }
            $repositoriesBlock
        """)
        file("included/src/main/kotlin/SettingsExtension.kt") << """
            import org.gradle.api.provider.*
            interface SettingsExtension {
                val myProperty: Property<Int>
            }
        """
        file("included/src/main/kotlin/settings-plugin.settings.gradle.kts") << """

    fun withK2BuildLogic() {
        withFile("build-logic/src/main/kotlin/MyTask.kt", """
            import org.gradle.api.DefaultTask
            import org.gradle.api.tasks.TaskAction

            abstract class MyTask : DefaultTask() {
                @TaskAction fun action() { println("Doing something") }
            }
        """)
        withFile("build-logic/src/main/kotlin/MyPlugin.kt", """
            import org.gradle.api.Project

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

description = """Persistent caches on disk and cross process locking.
    | Mostly for persisting Maps to the disk.
    | Also contains implementations for in-memory caches in front of the disk cache.
""".trimMargin()

dependencies {
    api(projects.concurrent)
    api(projects.stdlibJavaExtensions)
    api(projects.serialization)

    @Override
    String getLocation() {
        return "Plugin class 'SneakyPlugin'"
    }

    @Override
    void buildLogicApplication(BuildInputRead read) {
        dynamicGroovyPlugin(file("buildSrc/src/main/groovy/SneakyPlugin.groovy"), read)
        buildFile << """
            apply plugin: SneakyPlugin
        """
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.declarativedsl.evaluator.main

import org.gradle.declarative.dsl.evaluation.InterpretationSequence
import org.gradle.internal.declarativedsl.evaluator.schema.InterpretationSchemaBuilder

import org.gradle.internal.declarativedsl.objectGraph.ObjectReflection.ConstantValue
import org.gradle.internal.declarativedsl.objectGraph.ObjectReflection.DataObjectReflection


object ReflectionDemo {
    @JvmStatic
    fun main(args: Array<String>) {
        val code = """
            plugins {
                val kotlinVersion = "1.9.20"

                id("org.jetbrains.kotlin.jvm") version kotlinVersion

        // Therefore, it is impossible to call System.getProperties() with static import there, and testing static
        // import is important because Groovy generates different code in this case.
        file("buildSrc/src/main/groovy/SomePlugin.groovy") << """
            import ${CompileStatic.name}
            import ${Plugin.name}
            import ${Project.name}
            import static ${System.name}.clearProperty