// Generated from "bridgemethods/BridgeMethod.java"
@file:Suppress(
 "ALWAYS_NULL",
 "PARAMETER_NAME_CHANGED_ON_OVERRIDE",
 "SENSELESS_COMPARISON",
 "UNCHECKED_CAST",
 "UNNECESSARY_LATEINIT",
 "UNNECESSARY_NOT_NULL_ASSERTION",
 "UNREACHABLE_CODE",
 "UNUSED_ANONYMOUS_PARAMETER",
 "UNUSED_PARAMETER",
 "UNUSED_VARIABLE",
 "USELESS_CAST",
 "VARIABLE_IN_SINGLETON_WITHOUT_THREAD_LOCAL",
 "VARIABLE_WITH_REDUNDANT_INITIALIZER",
 "REDUNDANT_ELSE_IN_WHEN")

package bridgemethods

import javaemul.lang.*
import jsinterop.annotations.JsType
import kotlin.Any
import kotlin.AssertionError
import kotlin.Comparable
import kotlin.Double
import kotlin.Error
import kotlin.Number
import kotlin.String
import kotlin.Suppress

interface SomeInterface<T, S> {
 fun foo(t: T, s: S)

 fun foo(t: T, n: Number?)
}

open class SuperParent<T, S> internal constructor() {
 open fun foo(t: T, s: S) {}
}

open class Parent<T: Error?> internal constructor(): SuperParent<T, Number?>() {
 override fun foo(t: T, s: Number?) {}

 open fun <T_1: Number?> bar(t: T_1) {}

 open fun <T_1> `fun`(t: T_1) {}
}

open class BridgeMethod: Parent<AssertionError?>(), SomeInterface<AssertionError?, Number?> {
 override fun foo(a: AssertionError?, n: Number?) {}

 open fun `fun`(t: Number?) {}
}

fun interface SomeOtherFooInterface<T> {
 fun foo(t: T, s: Double?)
}

open class DualUnrelatedBridges internal constructor(): SomeInterface<String?, Double?>, SomeOtherFooInterface<String?> {
 override fun foo(s: String?, n: Double?) {}

 override fun foo(s: String?, n: Number?) {}
}

open class SuperDualUnrelatedAccidentalBridges internal constructor() {
 open fun foo(s: String?, n: Double?) {}

 open fun foo(s: String?, n: Number?) {}
}

open class DualUnrelatedAccidentalBridges internal constructor(): SuperDualUnrelatedAccidentalBridges(), SomeInterface<String?, Double?>, SomeOtherFooInterface<String?>

fun interface Getter {
 fun get(s: String?): String?
}

open class ClassWithParameterizedGet<T> internal constructor() {
 open fun get(t: T): T {
  return null as T
 }
}

open class AccidentalOverrideBridge internal constructor(): ClassWithParameterizedGet<String?>(), Getter {
 open fun test() {
  val g: Getter = AccidentalOverrideBridge()
  g.get("")
 }
}

open class TestCase10036 internal constructor() {
 @JsType
 interface BI3 {
  fun get(value: String?): String? {
   return "BI3 get String"
  }
 }

 fun interface BI2 {
  fun get(value: String?): String?
 }

 fun interface BI1: BI3 {
  override fun get(value: String?): String?
 }

 abstract class B<B1: Comparable<*>?> internal constructor(): BI1, BI2 {
  abstract fun get(value: B1): String?
 }
}

open class TestCase102 internal constructor() {
 @JsType
 fun interface BI2 {
  fun set(value: String?)
 }

 fun interface BI1 {
  fun set(value: String?)
 }

 abstract class B<B1> internal constructor(): BI1, BI2 {
  abstract fun set(value: B1)
 }

 open inner class C<B1> internal constructor(): B<B1>() {
  override fun set(value: String?) {}

  override fun set(value: B1) {}
 }
}

open class ParameterizedParent<T: ParameterizedParent<T>?> internal constructor() {
 internal open fun <Q: T> m_pp_bridgemethods(t: Q): Q {
  return null as Q
 }
}

open class ReparametrerizedChild<E: ReparametrerizedChild<E>?> internal constructor(): ParameterizedParent<E>() {
 override fun <S: E> m_pp_bridgemethods(t: S): S {
  return null as S
 }
}

open class LeafChild internal constructor(): ReparametrerizedChild<LeafChild?>()

fun interface StringConsumer {
 fun accept(s: String?)
}

open class Consumer<T> internal constructor() {
 fun accept(t: T) {}
}

open class StringConsumerImpl internal constructor(): Consumer<String?>(), StringConsumer

abstract class SpecializingReturnAbstractClass internal constructor() {
 abstract fun foo(): Any?
}

fun interface SpecializingReturnInterface {
 fun foo(): String?
}

abstract class SpecializingReturnAbstractSubclass internal constructor(): SpecializingReturnAbstractClass(), SpecializingReturnInterface

interface InterfaceWithDefaultMethod {
 fun foo(): Any? {
  return "A"
 }
}

fun interface InterfaceOverridingDefaultMethod: InterfaceWithDefaultMethod {
 override fun foo(): String?
}

abstract class DoesNotInheritDefaultMethod1 internal constructor(): InterfaceWithDefaultMethod, InterfaceOverridingDefaultMethod

abstract class DoesNotInheritDefaultMethod2 internal constructor(): InterfaceOverridingDefaultMethod, InterfaceWithDefaultMethod

open class PackagePrivateBridgeSuper<T, U> internal constructor() {
 internal open fun <S: T, R: PackagePrivateBridgeSuper<S, R>?> m_pp_bridgemethods(r: R, s: S, t: T, u: U) {}
}

class PackagePrivateBridge<V, W> internal constructor(): PackagePrivateBridgeSuper<V, W>() {
 public fun <S: V, R: PackagePrivateBridgeSuper<S, R>?> m(r: R, s: S, v: V, w: W) {}

 override fun <S: V, R: PackagePrivateBridgeSuper<S, R>?> m_pp_bridgemethods(arg0: R, arg1: S, arg2: V, arg3: W) {
  this.m(arg0, arg1, arg2, arg3)
 }
}
