@Override
            public List<GeneratedConstructor<T>> getConstructors() {
                List<GeneratedConstructor<T>> constructors = new ArrayList<GeneratedConstructor<T>>();
                for (final Constructor<?> constructor : type.getDeclaredConstructors()) {
                    constructors.add(new GeneratedConstructor<T>() {
                        @Override

 */

package org.gradle.internal.instantiation.generator

import spock.lang.Specification

class ConstructorComparatorTest extends Specification {
    def comparator = new ConstructorComparator()

    def "constructors with fewer parameters are first"() {
        def lhs = Stub(ClassGenerator.GeneratedConstructor)
        lhs.parameterTypes >> [String]
        def rhs = Stub(ClassGenerator.GeneratedConstructor)

        }

        if (constructors.isEmpty()) {
            throw failedImplicitBinding(key, "inject annotation on interface");
        }
        if (constructors.size() > 1) {
            throw failedImplicitBinding(key, "inject annotation on class with multiple constructors");
        }
        Constructor<T> declaredConstructor =
                (Constructor<T>) constructors.iterator().next();

    }

    def "fails when class has multiple constructors that are annotated"() {
        when:
        instantiator.newInstance(HasMultipleInjectConstructors, new StringBuilder("param"))

        then:
        ObjectInstantiationException e = thrown()
        e.cause.message == "Class DependencyInjectingInstantiatorTest.HasMultipleInjectConstructors has multiple constructors that are annotated with @Inject."
    }

    }

    def "fails when no constructors match parameters"() {
        when:
        instantiator.newInstance(HasConstructors, ["a", "b"] as Object[])

        then:
        ObjectInstantiationException e = thrown()
        e.cause instanceof IllegalArgumentException

        @Override
        protected CachedConstructor create(Class<?> receiver, Class<?>[] argumentTypes) {
            Constructor<?>[] constructors = receiver.getConstructors();
            Constructor<?> match = null;
            for (Constructor<?> constructor : constructors) {
                Class<?>[] parameterTypes = constructor.getParameterTypes();
                if (parameterTypes.length == argumentTypes.length) {

import org.gradle.internal.service.scopes.ServiceScope
import java.util.concurrent.ConcurrentHashMap


@ServiceScope(Scope.BuildTree::class)
class DefaultBeanStateReaderLookup(
    private val constructors: BeanConstructors,
    private val instantiatorFactory: InstantiatorFactory
) : BeanStateReaderLookup {

    private
    val beanStateReaders = ConcurrentHashMap<Class<*>, BeanStateReader>()

        constructors.forEach { yield(it.toKtConstructorSymbol(analysisContext)) }
    }
}

internal open class KaFe10ScopeNonStaticMember(
    scope: MemberScope,
    constructors: Collection<ConstructorDescriptor>,
    analysisContext: Fe10AnalysisContext
) : KaFe10ScopeMember(scope, constructors, analysisContext) {

  }

  private static <X extends Exception> List<Constructor<X>> preferringStringsThenThrowables(
      List<Constructor<X>> constructors) {
    return WITH_STRING_PARAM_THEN_WITH_THROWABLE_PARAM.sortedCopy(constructors);
  }

  // TODO: b/296487962 - Consider defining a total order over constructors.
  private static final Ordering<List<Class<?>>> ORDERING_BY_CONSTRUCTOR_PARAMETER_LIST =
      Ordering.natural()

        val functions = functionExtractor.memberFunctions(kClass, preIndex)
        val constructors = functionExtractor.constructors(kClass, preIndex)
        val name = kClass.fqName
        return DefaultDataClass(name, supertypesOf(kClass), properties, functions.toList(), constructors.toList())
    }

    private
    fun supertypesOf(kClass: KClass<*>): Set<FqName> = buildSet {