Generate compilable accessors for container elements of default packa…

…ge type

Relates to #1158

subprojects/integ-tests/src/test/kotlin/org/gradle/kotlin/dsl/integration/ProjectSchemaAccessorsIntegrationTest.kt

@@ -93,25 +93,19 @@ class ProjectSchemaAccessorsIntegrationTest : AbstractPluginIntegrationTest() {
     @Test
     fun `can access extension of default package type`() {
 
-        withFolders {
-
-            "buildSrc" {
-
-                withPrecompiledPlugins()
+        withBuildSrc {
 
-                "src/main/kotlin" {
+            "src/main/kotlin" {
 
-                    withFile("Extension.kt", """
-                        class Extension(private val name: String) : org.gradle.api.Named {
-                            override fun getName() = name
-                        }
-                    """)
+                withFile("Extension.kt", """
+                    class Extension(private val name: String) : org.gradle.api.Named {
+                        override fun getName() = name
+                    }
+                """)
 
-                    withFile("plugin.gradle.kts", """
-                        extensions.add("extension", Extension("foo"))
-                        extensions.add("beans", container(Extension::class))
-                    """)
-                }
+                withFile("plugin.gradle.kts", """
+                    extensions.add("extension", Extension("foo"))
+                """)
             }
         }
 
@@ -123,41 +117,83 @@ class ProjectSchemaAccessorsIntegrationTest : AbstractPluginIntegrationTest() {
 
             println("extension: " + typeOf(extension))
             extension { println("extension{} " + typeOf(this)) }
-
-            println("beans: " + typeOf(beans))
-            beans { println("beans{} " + typeOf(beans)) }
         """)
 
         assertThat(
             build("help", "-q").output,
             containsMultiLineString("""
                 extension: Extension
                 extension{} Extension
-                beans: org.gradle.api.NamedDomainObjectContainer<Extension>
-                beans{} org.gradle.api.NamedDomainObjectContainer<Extension>
             """)
         )
     }
 
     @Test
-    fun `can access task of default package type`() {
+    fun `can access container element of default package type`() {
 
-        withFolders {
+        withBuildSrc {
 
-            "buildSrc" {
+            "src/main/kotlin" {
 
-                withPrecompiledPlugins()
+                withFile("Bean.kt", """
+                    open class Bean(private val name: String) : org.gradle.api.Named {
+                        override fun getName() = name
+                    }
+                """)
 
-                "src/main/kotlin" {
+                withFile("plugin.gradle.kts", """
 
-                    withFile("CustomTask.kt", """
-                        open class CustomTask : org.gradle.api.DefaultTask()
-                    """)
+                    import org.gradle.api.internal.*
+                    import org.gradle.internal.reflect.*
 
-                    withFile("plugin.gradle.kts", """
-                        tasks.register<CustomTask>("customTask")
-                    """)
-                }
+                    val beans = DefaultPolymorphicDomainObjectContainer(
+                        Any::class.java,
+                        DirectInstantiator.INSTANCE
+                    ) { (it as Bean).name }
+
+                    // TODO: schema doesn't expose the registered element as Bean
+                    beans.register("bean", Bean::class)
+                    extensions.add("beans", beans)
+
+                """)
+            }
+        }
+
+        withBuildScript("""
+
+            plugins { id("plugin") }
+
+            inline fun <reified T> typeOf(value: T) = typeOf<T>()
+
+            println("beans: " + typeOf(beans))
+            println("bean: " + typeOf(beans.bean))
+            beans { println("beans{} " + typeOf(beans)) }
+        """)
+
+        // TODO: `bean` should be exposed as `Bean` in the collection schema
+        assertThat(
+            build("help", "-q").output,
+            containsMultiLineString("""
+                beans: org.gradle.api.NamedDomainObjectContainer<java.lang.Object>
+                bean: org.gradle.api.NamedDomainObjectProvider<java.lang.Object>
+                beans{} org.gradle.api.NamedDomainObjectContainer<java.lang.Object>
+            """)
+        )
+    }
+
+    @Test
+    fun `can access task of default package type`() {
+
+        withBuildSrc {
+            "src/main/kotlin" {
+
+                withFile("CustomTask.kt", """
+                    open class CustomTask : org.gradle.api.DefaultTask()
+                """)
+
+                withFile("plugin.gradle.kts", """
+                    tasks.register<CustomTask>("customTask")
+                """)
             }
         }
 

subprojects/provider/src/main/kotlin/org/gradle/kotlin/dsl/accessors/AccessorsClassPath.kt

@@ -247,16 +247,23 @@ fun sourceFilesWithAccessorsFor(projectSchema: ProjectSchema<TypeAccessibility>,
 }
 
 
-private
+internal
 fun importsRequiredBy(schemaSubset: ProjectSchema<TypeAccessibility>): List<String> =
     defaultPackageTypesIn(
-        schemaSubset
-            .run { extensions.flatMap { listOf(it.target, it.type) } + tasks.map { it.type } }
+        candidateTypesForImportIn(schemaSubset)
             .filterIsInstance<TypeAccessibility.Accessible>()
             .map { it.type }
     )
 
 
+private
+fun candidateTypesForImportIn(projectSchema: ProjectSchema<TypeAccessibility>) = projectSchema.run {
+    (extensions.flatMap { listOf(it.target, it.type) }
+        + tasks.map { it.type }
+        + containerElements.map { it.type })
+}
+
+
 internal
 fun defaultPackageTypesIn(typeStrings: List<String>): List<String> =
     typeStrings

subprojects/provider/src/test/kotlin/org/gradle/kotlin/dsl/accessors/DefaultPackageTypesTest.kt

@@ -16,6 +16,8 @@
 
 package org.gradle.kotlin.dsl.accessors
 
+import org.gradle.kotlin.dsl.accessors.TypeAccessibility.Accessible
+
 import org.hamcrest.CoreMatchers.equalTo
 import org.hamcrest.MatcherAssert.assertThat
 
@@ -32,4 +34,29 @@ class DefaultPackageTypesTest {
             equalTo(listOf("Extension"))
         )
     }
+
+    @Test
+    fun `#importsRequiredBy takes container elements into account`() {
+
+        assertThat(
+            importsRequiredBy(
+                ProjectSchema(
+                    containerElements = listOf(
+                        ProjectSchemaEntry(
+                            Accessible("Container"),
+                            "element",
+                            Accessible("DefaultPackageType")
+                        )
+                    ),
+                    extensions = emptyList(),
+                    conventions = emptyList(),
+                    tasks = emptyList(),
+                    configurations = emptyList()
+                )
+            ),
+            equalTo(
+                listOf("DefaultPackageType")
+            )
+        )
+    }
 }