constructorsSupplier.get().firstOrNull { c -> jvmSignature == c.signature?.asString() }?.flags?.let { predicate(it) } ?: false


private
fun hasFunctionFlags(functionsSupplier: Supplier<MutableList<KmFunction>>, jvmSignature: String, predicate: FlagsPredicate) =
    functionsSupplier.get().firstOrNull {
        jvmSignature == it.signature?.asString()

        "${declaringClass.baseQualifiedKotlinName}.${field.name}".let { fqn ->
            collectDescendantsOfType<KtProperty>()
                .firstOrNull { it.fqName?.asString() == fqn }
                ?.isDocumentedAsSince(version) == true
        }

    private

            null
        } else {
            val testCoverages = model.stages.flatMap { it.functionalTests }
            val foundTestCoverage = testCoverages.firstOrNull {
                it.testType == TestType.platform &&
                    it.os == testCoverage.os &&
                    it.buildJvm == testCoverage.buildJvm
            }
            foundTestCoverage?.let {

            throw IllegalStateException("Can't find the contributors section in the release notes $releaseNotes.")
        }

        val contributorSectionEndIndex = (contributorSectionBeginIndex until releaseNotesLines.size).firstOrNull {
            val line = releaseNotesLines[it].trim()
            line.isNotEmpty() && !line.startsWith("[")
        } ?: throw IllegalStateException("Can't find the contributors section end in the release notes $releaseNotes.")

                if (idx < versionsByMinor.size - 1) {
                    add(entry.value.first())
                } else {
                    add(entry.value.firstOrNull { !it.contains("-") })
                    add(entry.value.first())
                }
            }
            add(minimumSupported)
        }.filterNotNull().distinct().sorted()

        classFilePathCandidatesFor(sourceName)
            .mapNotNull(::classBytesSupplierForFilePath)
            .firstOrNull()

    private
    fun classBytesSupplierForFilePath(classFilePath: String): ClassBytesSupplier? =
        classBytesIndex.asSequence().mapNotNull { it(classFilePath) }.firstOrNull()

    private
    fun sourceNamesFrom(entry: File): Sequence<String> =
        when {

     */
    fun sourceFileAndSourceRootFor(sourceFilePath: String): Pair<File, File> =
        sourceRoots.asSequence()
            .map { it.resolve(sourceFilePath) to it }
            .firstOrNull { it.first.isFile }
            ?: throw IllegalStateException("Source file '$sourceFilePath' not found, searched in source roots:\n  - ${sourceRoots.joinToString("\n  - ")}")

    private

            listOf(testProjectToScenarioDurations, testProjectScenarioDurationsFallback)
                .mapNotNull { it.getOrDefault(scenario.testProject, emptyList()).firstOrNull { duration -> duration.scenario == scenario.scenario } }
                .firstOrNull() ?: PerformanceTestDuration(scenario.scenario, 1) // Fallback for new performance tests (don't use 0 to avoid division by zero)
        })
        .entries

        .sortedWithTypeOfTakingFunctionsFirst()
        .flatMap { function ->

            val candidateFor = object {

                val groovyNamedArgumentsToVarargs =
                    function.parameters.firstOrNull()?.type?.isGroovyNamedArgumentMap == true

                val javaClassToKotlinClass =
                    function.parameters.any { it.type.hasJavaClass() }

                val extension