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 {

 */

package org.gradle.internal.instantiation.generator;

import java.util.Comparator;

/**
 * Sorts GeneratedConstructors based on the number of parameters.
 *
 * When two constructors have the same number of parameters, we settle on a stable sort by looking at the names of the
 * types of the parameters.
 *
 */

import org.gradle.internal.service.ServiceRegistry
import org.gradle.internal.state.ModelObject
import java.lang.reflect.Field


class BeanPropertyReader(
    private val beanType: Class<*>,
    private val constructors: BeanConstructors,
    instantiatorFactory: InstantiatorFactory
) : BeanStateReader {
    // TODO should use the same scheme as the original bean
    private

  }

  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()

classes\ that\ are\ not\ special\ class\ and\ are\ injected\ into\ getters\ via\ @Inject\ or\ are\ injected\ into\ constructors\ via\ @Inject\ should\ be\ annotated\ with\ @ServiceScope=injected-services-should-have-service-scope-applied.txt

import org.gradle.internal.service.scopes.ServiceScope
import sun.reflect.ReflectionFactory
import java.lang.reflect.Constructor


/**
 * A global service that caches the serialization constructors for bean types.
 */
@ServiceScope(Scope.Global::class)
class BeanConstructors(
    cacheFactory: CrossBuildInMemoryCacheFactory
) {
    private

        extractors.flatMapTo(mutableSetOf()) { it.memberFunctions(kClass, preIndex) }

    override fun constructors(kClass: KClass<*>, preIndex: DataSchemaBuilder.PreIndex): Iterable<DataConstructor> =
        extractors.flatMapTo(mutableSetOf()) { it.constructors(kClass, preIndex) }

    override fun topLevelFunction(function: KFunction<*>, preIndex: DataSchemaBuilder.PreIndex): DataTopLevelFunction? =

import spock.lang.Issue

class ObjectExtensionInstantiationIntegrationTest extends AbstractIntegrationSpec {
    // Document current behaviour
    def "can create instance of extension with multiple constructors without @Inject annotation"() {
        buildFile """
            class Thing {
                String a
                String b
                Thing(String a, String b = a) {
                    this.a = a

package main

type A []int;
type M map[int] int;

func main() {
	var a *A = &A{0};
	var m *M = &M{0 : 0};  // should be legal to use & here for consistency with other composite constructors (prev. line)
	_, _ = a, m;
}

/*
uetli:~/Source/go1/test/bugs gri$ 6g bug098.go && 6l bug098.6 && 6.out
bug098.go:10: illegal types for operand: AS
	(*MAP[<int32>INT32]<int32>INT32)

import org.jetbrains.kotlin.resolve.scopes.MemberScope

internal class KaFe10PackageScope(
    scope: MemberScope,
    private val owner: KaPackageSymbol,
    analysisContext: Fe10AnalysisContext
) : KaFe10ScopeMember(scope, constructors = emptyList(), analysisContext) {
    override fun getPackageSymbols(nameFilter: KaScopeNameFilter): Sequence<KaPackageSymbol> = withValidityAssertion {