dependant.cookie_params.append(field)


def is_coroutine_callable(call: Callable[..., Any]) -> bool:
    if inspect.isroutine(call):
        return inspect.iscoroutinefunction(call)
    if inspect.isclass(call):
        return False
    dunder_call = getattr(call, "__call__", None)  # noqa: B004
    return inspect.iscoroutinefunction(dunder_call)


def is_async_gen_callable(call: Callable[..., Any]) -> bool:

)

// Standard constants for all storage class
const (
	// Reduced redundancy storage class
	RRS = "REDUCED_REDUNDANCY"
	// Standard storage class
	STANDARD = "STANDARD"
)

// Standard constats for config info storage class
const (
	ClassStandard = "standard"
	ClassRRS      = "rrs"
	Optimize      = "optimize"
	InlineBlock   = "inline_block"

	// Reduced redundancy storage class environment variable

import japicmp.util.Optional
import javassist.CtClass
import me.champeau.gradle.japicmp.report.Violation

class MethodsRemovedInInternalSuperClassRuleTest extends AbstractContextAwareRuleSpecification {
    MethodsRemovedInInternalSuperClassRule rule

    static class OldSuperInternal {
        void publicMethod() {}

        private void privateMethod() {}
    }

    static class OldBase extends OldSuperInternal {

$body.hasClass(CLASS_NAME_NAVBAR_LG_FIXED) ||\n        $body.hasClass(CLASS_NAME_NAVBAR_XL_FIXED)\n    )\n  }\n\n  _isFooterFixed() {\n    const $body = $('body')\n    return (\n      $body.hasClass(CLASS_NAME_FOOTER_FIXED) ||\n        $body.hasClass(CLASS_NAME_FOOTER_SM_FIXED) ||\n        $body.hasClass(CLASS_NAME_FOOTER_MD_FIXED) ||\n        $body.hasClass(CLASS_NAME_FOOTER_LG_FIXED) ||\n        $body.hasClass(CLASS_NAME_FOOTER_XL_FIXED)\n    )\n  }\n\n  _fixScrollHeight() {\n    const $body = $('body')\n    const...

        is JApiMethod -> newMethod.get()
        else -> error("Unsupported japicmp member type '${this::class}'")
    }


/**
 * [CtClass] or [CtMember].
 */
private
typealias CtClassOrCtMember = Any


private
val CtClassOrCtMember.declaringClass: CtClass
    get() = when (this) {
        is CtClass -> declaringClass ?: this
        is CtMember -> declaringClass

import japicmp.filter.ClassFilter
import javassist.CtClass
import org.gradle.api.Generated

/**
 * $$BridgeFor$$ classes generated for bytecode upgrade instrumentation
 */
class BridgeForBytecodeUpgradeAdapterClassFilter implements ClassFilter {

    private static final BRIDGE_CLASS_PREFIX = "\$\$BridgeFor\$\$"

    @Override
    boolean matches(CtClass ctClass) {

      )
    }
  }

  @ExperimentalOkHttpApi
  companion object {
    @RequiresApi(Build.VERSION_CODES.Q)
    val IPv4 = AndroidAsyncDns(dnsClass = AsyncDns.DnsClass.IPV4)

    @RequiresApi(Build.VERSION_CODES.Q)
    val IPv6 = AndroidAsyncDns(dnsClass = AsyncDns.DnsClass.IPV6)
  }

import kotlin.reflect.KClass
import okhttp3.internal.concurrent.TaskRunner
import okhttp3.internal.http2.Http2

object OkHttpDebugLogging {
  // Keep references to loggers to prevent their configuration from being GC'd.
  private val configuredLoggers = CopyOnWriteArraySet<Logger>()

  fun enableHttp2() = enable(Http2::class)

  fun enableTaskRunner() = enable(TaskRunner::class)

  fun logHandler() =

object KotlinMetadataQueries {

    fun isKotlinFileFacadeClass(ctClass: CtClass): Boolean =
        if (Modifier.isPrivate(ctClass.modifiers)) false
        else queryKotlinMetadata(ctClass) { metadata ->
            when (metadata) {
                is KotlinClassMetadata.FileFacade -> true
                else -> false
            }
        }

    fun isKotlinInternal(ctClass: CtClass): Boolean =

    @Incubating
    static class NewIncubatingBase extends NewSuper {}

    @Incubating
    interface IncubatingInterface {}

    interface InternalInterface {}

    interface StablePublicInterface {}

    CtClass oldBase
    CtClass newBase
    CtClass newSuper
    CtClass newIncubatingBase
    CtClass internalInterface
    CtClass incubatingInterface
    CtClass stablePublicInterface

    Map interfaces