return constructor.getGenericParameterTypes();
        }

        private Member getFactory() {
            return constructor;
        }

        @Override
        protected String getFactoryDisplayName() {
            return String.format("%s constructor", format(getFactory().getDeclaringClass()));
        }

        @Override
        protected Object invokeMethod(Object[] params) {
            try {

import org.jetbrains.kotlin.analysis.api.renderer.base.annotations.renderers.KaAnnotationUseSiteTargetRenderer
import org.jetbrains.kotlin.analysis.utils.printer.PrettyPrinter

public class KaAnnotationRenderer internal constructor(
    public val annotationListRenderer: KaAnnotationListRenderer,
    public val annotationFilter: KaRendererAnnotationsFilter,
    public val annotationsQualifiedNameRenderer: KaAnnotationQualifierRenderer,

    private final ArrayBlockingQueue<Exchange> eventQueue;

    /**
     * Constructor that makes passed in delegate run on single thread, and will block on last event.
     */
    public SimplexTransferListener(TransferListener delegate) {
        this(delegate, QUEUE_SIZE, BATCH_MAX_SIZE, true);
    }

    /**
     * Constructor that may alter behaviour of this listener.
     *

import org.jetbrains.kotlin.analysis.utils.printer.PrettyPrinter
import org.jetbrains.kotlin.lexer.KtKeywordToken

public class KaKeywordsRenderer private constructor(
    public val keywordRenderer: KaKeywordRenderer,
    public val keywordFilter: KaRendererKeywordFilter,
) {

import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.platform.TargetPlatform

public class KotlinCompositePackageProvider private constructor(
    override val providers: List<KotlinPackageProvider>,
) : KotlinPackageProvider(), KotlinCompositeProvider<KotlinPackageProvider> {
    override fun doesPackageExist(packageFqName: FqName, platform: TargetPlatform): Boolean {

import org.gradle.internal.service.scopes.ServiceScope


/**
 * Holds the list of imports implicitly added to every Kotlin build script.
 */
@ServiceScope(Scope.Global::class)
class ImplicitImports internal constructor(
    @Transient
    private val importsReader: ImportsReader
) {

    val list by lazy {
        gradleImports() + gradleKotlinDslImports()
    }

    private
    fun gradleImports() =

import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
import org.jetbrains.kotlin.name.ClassId

internal class KaFirAnnotationListForReceiverParameter private constructor(
    private val firCallableSymbol: FirCallableSymbol<*>,
    private val receiverParameter: FirAnnotationContainer,
    private val builder: KaSymbolByFirBuilder,
) : AbstractList<KaAnnotation>(), KaAnnotationList {

        when:
        DeprecationLogger.deprecateInternalApi("constructor DefaultPolymorphicDomainObjectContainer(Class<T>, Instantiator)")
            .replaceWith("ObjectFactory.polymorphicDomainObjectContainer(Class<T>)")
            .willBeRemovedInGradle9()
            .undocumented()
            .nagUser()

        then:

If the type contains an abstract property called "name" of type `String`, Gradle provides an implementation for the getter
method, and extends each constructor with a "name" parameter, which comes before all other constructor parameters.

If the type is an interface, Gradle will provide a constructor with a single "name" parameter and `@Inject` semantics.

import org.jetbrains.kotlin.utils.addToStdlib.partitionIsInstance

/**
 * With each call to [merge], [SublistMerger] can merge all elements of a specific (reified) type into a single element using a supplied
 * constructor and then add it to [destination]. Unmerged elements are added to [destination] using [finish].
 *
 * The purpose of [SublistMerger] is to merge multiple different types of elements from a single origin list without the need for