}
                    return null
                }
            }
        )

    fun getSince(member: JApiCompatibility): JavaSourceQuery<SinceTagStatus> =
        member.jApiClass.simpleName.let { declaringClassSimpleName ->
            JavaSourceQuery(
                SinceTagStatus.Missing,
                when (member) {
                    is JApiClass -> getSinceJavaClassVisitorFor(declaringClassSimpleName)

 *       .where(new TypeParameter<T>() {}, elementType);
 * }
 * }
 *
 * @author Ben Yu
 * @since 12.0
 */
/*
 * A nullable bound would let users create a TypeParameter instance for a parameter with a nullable
 * bound. However, it would also let them create `new TypeParameter<@Nullable T>() {}`, which
 * wouldn't behave as users might expect. Additionally, it's not clear how the TypeToken API could

                    "/invoices/": {
                        "post": {
                            "summary": "Create Invoice",

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


private
fun hasFunctionAttribute(functionsSupplier: Supplier<MutableList<KmFunction>>, jvmSignature: String, predicate: AttributePredicate) =
    functionsSupplier.get().firstOrNull {
        jvmSignature == it.signature?.toString()
    }?.let { predicate.match(it) } ?: false


private

            .accept(query.visitor, null)
            ?: query.defaultValue


    fun <T : Any?> executeQuery(apiSourceFile: ApiSourceFile.Kotlin, transform: (KtFile) -> T): T =
        apiSourceFile.normalizedPath.let { sourceNormalizedPath ->
            openKotlinCompilationUnitsByRoot
                .computeIfAbsent(apiSourceFile.currentSourceRoot) {
                    KotlinSourceParser().parseSourceRoots(

   * {@code throws} clause: Some such methods can in fact throw a checked exception (e.g., by
   * calling code written in Kotlin).) Typically, we want to let a {@link Throwable} from such a
   * method propagate untouched, just as we'd typically let it do for a non-reflective call.
   * However, we can't usually write {@code throw t;} when {@code t} has a static type of {@link

   * {@code throws} clause: Some such methods can in fact throw a checked exception (e.g., by
   * calling code written in Kotlin).) Typically, we want to let a {@link Throwable} from such a
   * method propagate untouched, just as we'd typically let it do for a non-reflective call.
   * However, we can't usually write {@code throw t;} when {@code t} has a static type of {@link

        Pair(
            (node as? NodeWithJavadoc<*>)?.javadoc?.orElse(null)?.let { findVersionFromJavadoc(it) }
                // This is needed to find the JavaDoc of a package declaration in 'package-info.java'
                ?: (node as? PackageDeclaration)?.parentNode?.get()?.childNodes?.filterIsInstance<JavadocComment>()?.singleOrNull()?.parse()?.let { findVersionFromJavadoc(it) }
                ?: VERSION_NOT_FOUND,

        return when {
            sinceTags.isEmpty() -> {
                fallback?.let { SinceTagStatus.Present(it) } ?: SinceTagStatus.Missing
            }

            sinceTags.all { it == sinceTags.first() } -> {
                (sinceTags.first() ?: fallback)?.let { SinceTagStatus.Present(it) } ?: SinceTagStatus.Missing
            }

            else -> {

   * {@code throws} clause: Some such methods can in fact throw a checked exception (e.g., by
   * calling code written in Kotlin).) Typically, we want to let a {@link Throwable} from such a
   * method propagate untouched, just as we'd typically let it do for a non-reflective call.
   * However, we can't usually write {@code throw t;} when {@code t} has a static type of {@link