}

    @Override
    public Set<Class<? extends Annotation>> getInjectionAnnotations() {
        return injectionAnnotations;
    }

    @Override
    public <T> InstanceFactory<T> forType(Class<T> type) {
        return instantiator.factoryFor(type);
    }

    @Override
    public InstantiationScheme withServices(ServiceLookup services) {

        // We don't know whether the task is cacheable or not, so we ignore cacheability problems for scheduling
        TypeValidationContext typeValidationContext = validationContext.forType(taskType, false);
        node.getTaskProperties().validateType(typeValidationContext);
        return validationContext;
    }

    private void logWarnings(List<? extends Problem> problems) {
        problems.stream()

    }

    public DefaultNamedDomainObjectSet(Class<? extends T> type, Instantiator instantiator, CollectionCallbackActionDecorator decorator) {
        this(type, instantiator, Named.Namer.forType(type), decorator);
    }

    // should be protected, but use of the class generator forces it to be public

    public void vetoParameters(ClassGenerator.GeneratedConstructor<?> constructor, Object[] parameters) {
        // Don't care
    }

    @Override
    public <T> ClassGenerator.GeneratedConstructor<? extends T> forType(Class<T> type) throws UnsupportedOperationException {
        throw new UnsupportedOperationException("This constructor selector requires the construction parameters");
    }

    @Override

        Class<?> workType = workClass.get();
        TypeValidationContext workValidationContext = validationContext.forType(workType, true);
        validateImplementation(workValidationContext, beforeExecutionState.getImplementation(), "Implementation of ", work);
        beforeExecutionState.getAdditionalImplementations()

        }
    }

    public <T> InstanceFactory<T> factoryFor(final Class<T> type) {
        final ClassGenerator.GeneratedConstructor<? extends T> constructor = constructorSelector.forType(type);
        return new InstanceFactory<T>() {
            @Override
            public boolean serviceInjectionTriggeredByAnnotation(Class<? extends Annotation> injectAnnotation) {

        expect:
        def arraySerializer = serializer.forTypes([String, Long, String] as Class[])
        serialize(["a", 12L, "b"] as Object[], arraySerializer) == ["a", 12L, "b"] as Object[]
    }

    def "falls back to default when no serializer registry knows about types"() {
        given:
        def serializer = Stub(Serializer)
        defaultArgsBuilder.forTypes(_) >> serializer

        expect:

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

type FooType[T any] interface {
	Foo(BarType[T]) string
}
type BarType[T any] interface {
	Bar(FooType[T]) string
}

// For now, a lone type parameter is not permitted as RHS in a type declaration (issue #45639).
// type Baz[T any] T

        expect:
        def arraySerializer = serializer.forTypes([] as Class[])
        serialize([] as Object[], arraySerializer).length == 0
        toBytes([] as Object[], arraySerializer).length == 0
    }

    def "serializes single args"() {
        expect:
        def arraySerializer = serializer.forTypes([String,] as Class[])
        serialize(["a"] as Object[], arraySerializer) == ["a"] as Object[]

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

type FooType[t any] interface {
	Foo(BarType[t])
}
type BarType[t any] interface {
	Int(IntType[t]) FooType[int]
}

type IntType[t any] int

func (n IntType[t]) Foo(BarType[t]) {}