MethodHandle spreader = original.asSpreader(Object[].class, original.type().parameterCount());
        MethodHandle decorated = MethodHandles.insertArguments(INTERCEPTOR, 0, this, spreader, flags, caller.lookupClass().getName());
        return decorated.asCollector(Object[].class, original.type().parameterCount()).asType(original.type());
    }

        }

        val parameterCount = declaration.valueParameters.size + (if (declaration.isExtensionDeclaration()) 1 else 0)

        val function = when {
            declaration.hasModifier(KtTokens.SUSPEND_KEYWORD) -> analysisContext.builtIns.getSuspendFunction(parameterCount)
            else -> analysisContext.builtIns.getFunction(parameterCount)
        }

    private
    fun writeReplaceMethodFrom(candidates: List<Method>) =
        candidates.firstAccessibleMatchingMethodOrNull {
            !Modifier.isStatic(modifiers)
                && parameterCount == 0
                && returnType == java.lang.Object::class.java
                && name == "writeReplace"
        }

    private
    fun writeObjectMethodHierarchyFrom(candidates: List<Method>) = candidates

            readObjectMethodHierarchyFrom(it.allMethods())
        }
}


internal
fun Method.isReadResolve() =
    !isStatic(modifiers)
        && parameterCount == 0
        && returnType == java.lang.Object::class.java
        && name == "readResolve"


internal
fun readObjectMethodHierarchyFrom(candidates: List<Method>): List<Method> = candidates

            .findAll { it.propertyType == boolean }
            .findAll { p -> StartParameterInternal.methods.find { m -> m.name == "set" + p.name.capitalize() && m.parameterCount == 1 && m.parameterTypes[0] == Boolean.TYPE } }
            .collect { it.name }
    }

    def "serializes BuildModelAction"() {
        def startParameter = new StartParameterInternal()

    private
    fun Class<*>.dependencyHandlerExtensionMethods(name: String): List<Method> {
        return declaredMethods.filter(Method::isPublicStatic)
            .filter { it.name == name }
            .filter { it.parameterCount > 0 }
            .filter { it.parameterTypes[0].simpleName == "DependencyHandler" }
    }

    private
    fun isDeprecated(it: Method) = it.annotations.map { it.annotationClass }.contains(Deprecated::class)

Parameterized$RunnersFactory { private static final parameterized.ParametersRunnerFact DEFAULT_FACTORY; private final model.TestClass testClass; private final model.FrameworkMethod parametersMethod; private final java.util.List allParameters; private final int parameterCount; private final org.junit.runner.Runner runnerOverride; private void Parameterized$RunnersFactory(Class) throws Throwable; private java.util.List createRunners() throws Exception; private parameterized.ParametersRunnerFact getParametersRunnerF()...

            }
            is FirFunctionTypeRef -> {
                val classId = if (isSuspend) {
                    StandardNames.getSuspendFunctionClassId(parametersCount)
                } else {
                    StandardNames.getFunctionClassId(parametersCount)
                }
                buildString {
                    append(classId.asSingleFqName().toString())
                    val parameters = buildList {

        val kind: String
    }

    interface NativeIndexerWrongParameterCount : KaFirDiagnostic<KtElement> {
        override val diagnosticClass get() = NativeIndexerWrongParameterCount::class
        val parametersCount: Int
        val kind: String
    }

    interface NativeIndexerCanNotHaveDefaultArguments : KaFirDiagnostic<KtElement> {
        override val diagnosticClass get() = NativeIndexerCanNotHaveDefaultArguments::class

    token: KaLifetimeToken,
) : KaAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KaFirDiagnostic.NativeIndexerKeyShouldBeStringOrNumber

internal class NativeIndexerWrongParameterCountImpl(
    override val parametersCount: Int,
    override val kind: String,
    firDiagnostic: KtPsiDiagnostic,
    token: KaLifetimeToken,
) : KaAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KaFirDiagnostic.NativeIndexerWrongParameterCount