From mobile apps to microservices, from small startups to big enterprises, Gradle helps teams build, automate and deliver better software, faster.

Gradle Community

I have a plugin `FooPlugin` creating an extension:
```interface FooExtension {
  val foos: NamedDomainObjectContainer&lt;Foo&gt;
}
abstract class Foo(private val name: String): Named {
  override fun getName() = name
}
class FooPlugin : Plugin&lt;Project&gt; {
  override fun apply(project: Project) {
    val fooExt = project.extensions.create("foo", FooExtension::class.java)
    fooExt.foos.register("testFoo")
  }
}

// build.gradle.kts
foo.foos.testFoo // Unresolved reference.```

```interface FooExtension : NamedDomainObjectContainer&lt;Foo&gt;

class FooPlugin : Plugin&lt;Project&gt; {
    override fun apply(project: Project) {
        project.extensions.create&lt;FooExtension&gt;("foo", ...)```

your original _might_ work if <https://github.com/gradle/gradle/issues/9264> is resolved (although I think you will still need a unique type for the container), but it won't currently

Thanks for the link! But now I am unable to create an instance of the extension
```Could not create an instance of type FooExtension.
      &gt; Could not generate a decorated class for type FooExtension.
         &gt; Cannot have abstract method NamedDomainObjectCollection.getAsMap().```

you might have to do it the long-winded way,
```internal class DefaultFooExtension @Inject constructor(
    private val objects: ObjectFactory,
) : AbstractNamedDomainObjectContainer(), FooExtension {
    override fun doCreate(name: String): Foo = objects.newInstance(name)
}

val fooExtension = project.objects.newInstance&lt;DefaultFooExtension&gt;()
project.extensions.add&lt;FooExtension&gt;("foo", fooExtension)```

hmm AbstractNamedDomainObjectContainer is internal. I'm not entirely sure what the correct public way to do this is

maybe you could
```project.extensions.add("foo", project.objects.domainObjectContainer&lt;Foo&gt;())```
but you wouldn't be able to add your own functions to it

Yeah, that works, nice. As a workaround, I add two extensions, one typed holder containing the elements and another for my functions. Thank you!