events: Prefer using Class

There was no reason to use `KClass` here

Author: freya022

BotCommands-core/src/main/kotlin/io/github/freya022/botcommands/internal/core/ClassPathFunction.kt

@@ -13,6 +13,7 @@ private typealias ClassPathFunctionIterable = Iterable<ClassPathFunction>
 
 internal sealed class ClassPathFunction {
     abstract val clazz: KClass<*>
+    abstract val javaClazz: Class<*>
     abstract val instance: Any
 
     abstract val function: KFunction<*>
@@ -38,6 +39,8 @@ internal class LazyClassPathFunction internal constructor(
     override val clazz: KClass<*>,
     method: Method
 ) : ClassPathFunction() {
+
+    override val javaClazz: Class<*> get() = clazz.java
     override val function: KFunction<*> by lazy { method.asKFunction() }
     override val instance by context.serviceContainer.lazy(clazz)
     override val methodAccessor: MethodAccessor<*> by lazy { MethodAccessorFactoryProvider.getAccessorFactory().create(instance, function) }
@@ -52,6 +55,7 @@ internal class InstanceClassPathFunction internal constructor(
     override val function: KFunction<*>
 ) : ClassPathFunction() {
     override val clazz: KClass<*> get() = instance::class
+    override val javaClazz: Class<*> get() = instance.javaClass
     override val methodAccessor = MethodAccessorFactoryProvider.getAccessorFactory().create(instance, function)
 }
 

BotCommands-core/src/main/kotlin/io/github/freya022/botcommands/internal/core/hooks/EventDispatcherImpl.kt

@@ -29,7 +29,7 @@ internal class EventDispatcherImpl internal constructor(
 
     internal fun onEvent(event: GenericEvent) {
         // No need to check for `event` type as if it's in the map, then it's recognized
-        val handlers = eventListenerRegistry[event::class] ?: return
+        val handlers = eventListenerRegistry[event.javaClass] ?: return
 
         // Run blocking handlers first
         handlers[RunMode.BLOCKING]?.let { eventHandlers ->
@@ -63,7 +63,7 @@ internal class EventDispatcherImpl internal constructor(
 
     override suspend fun dispatchEvent(event: Any) {
         // No need to check for `event` type as if it's in the map, then it's recognized
-        val handlers = eventListenerRegistry[event::class] ?: return
+        val handlers = eventListenerRegistry[event.javaClass] ?: return
 
         // Run blocking handlers first
         handlers[RunMode.BLOCKING]?.forEach { eventHandler ->
@@ -86,7 +86,7 @@ internal class EventDispatcherImpl internal constructor(
     override fun dispatchEventAsync(event: Any): List<Deferred<Unit>> {
         // Try not to switch context on non-handled events
         // No need to check for `event` type as if it's in the map, then it's recognized
-        val handlers = eventListenerRegistry[event::class] ?: return emptyList()
+        val handlers = eventListenerRegistry[event.javaClass] ?: return emptyList()
 
         return handlers.map { eventHandler ->
             asyncCoroutineScope.async { runEventHandler(eventHandler, event) }

BotCommands-core/src/main/kotlin/io/github/freya022/botcommands/internal/core/hooks/EventListenerRegistry.kt

@@ -16,21 +16,19 @@ import io.github.freya022.botcommands.internal.core.service.canCreateWrappedServ
 import io.github.freya022.botcommands.internal.core.service.tryGetWrappedService
 import io.github.freya022.botcommands.internal.core.toClassPathFunctions
 import io.github.freya022.botcommands.internal.utils.*
-import io.github.freya022.botcommands.internal.utils.ReflectionUtils.declaringClass
 import io.github.freya022.botcommands.internal.utils.ReflectionUtils.nonInstanceParameters
 import io.github.oshai.kotlinlogging.KotlinLogging
 import net.dv8tion.jda.api.events.Event
 import net.dv8tion.jda.api.events.GenericEvent
 import net.dv8tion.jda.api.requests.GatewayIntent
 import java.util.concurrent.ConcurrentHashMap
-import kotlin.reflect.KClass
 import kotlin.reflect.full.functions
 import kotlin.reflect.jvm.jvmErasure
 import kotlin.time.Duration
 import kotlin.time.toDuration
 import kotlin.time.toDurationUnit
 
-private typealias EventMap = MutableMap<KClass<*>, EventListenerList>
+private typealias EventMap = MutableMap<Class<*>, EventListenerList>
 
 private val logger = KotlinLogging.logger { }
 
@@ -54,7 +52,7 @@ internal class EventListenerRegistry internal constructor(
             .addAsEventListeners()
     }
 
-    internal operator fun get(eventType: KClass<*>): EventListenerList? {
+    internal operator fun get(eventType: Class<*>): EventListenerList? {
         return map[eventType]
     }
 
@@ -67,7 +65,7 @@ internal class EventListenerRegistry internal constructor(
     }
 
     internal fun removeEventListener(listener: Any) {
-        listeners.remove(listener::class.java)?.let { instanceMap ->
+        listeners.remove(listener.javaClass)?.let { instanceMap ->
             instanceMap.forEach { (kClass, functions) ->
                 val functionMap = map[kClass]
                     ?: throwInternal("Listener was registered without having its functions added to the listener map")
@@ -89,10 +87,10 @@ internal class EventListenerRegistry internal constructor(
 
             val parameters = function.nonInstanceParameters
 
-            val eventErasure = parameters.first().type.jvmErasure
+            val eventErasure = parameters.first().type.jvmErasure.java
             if (!annotation.ignoreIntents && eventErasure.isSubclassOf<Event>()) {
                 @Suppress("UNCHECKED_CAST")
-                val requiredIntents = GatewayIntent.fromEvents(eventErasure.java as Class<out Event>)
+                val requiredIntents = GatewayIntent.fromEvents(eventErasure as Class<out Event>)
                 val missingIntents = requiredIntents - jdaService.intents - config.ignoredIntents - annotation.ignoredIntents
                 if (missingIntents.isNotEmpty()) {
                     return@forEach logger.debug { "Skipping event listener ${function.shortSignature} as it is missing intents: $missingIntents" }
@@ -123,7 +121,7 @@ internal class EventListenerRegistry internal constructor(
                 })
 
             val allEventTypes = eventTreeService.getSubclasses(eventErasure) + eventErasure
-            classPathFunc.function.declaringClass.java.let { clazz ->
+            classPathFunc.javaClazz.let { clazz ->
                 val instanceMap = listeners.computeIfAbsent(clazz) { hashMapOf() }
 
                 allEventTypes.forEach {

BotCommands-core/src/main/kotlin/io/github/freya022/botcommands/internal/core/hooks/EventTreeService.kt

@@ -6,25 +6,23 @@ import io.github.freya022.botcommands.api.core.service.annotations.BService
 import io.github.oshai.kotlinlogging.KotlinLogging
 import net.dv8tion.jda.api.events.GenericEvent
 import java.util.*
-import kotlin.reflect.KClass
-import kotlin.reflect.jvm.jvmName
 
 private val logger = KotlinLogging.logger { }
 
 @BService
 internal class EventTreeService internal constructor() {
-    private val map: Map<KClass<*>, List<KClass<*>>> = ClassGraph()
+    private val map: Map<Class<*>, List<Class<*>>> = ClassGraph()
         .acceptPackages(GenericEvent::class.java.packageName, BGenericEvent::class.java.packageName)
         .disableRuntimeInvisibleAnnotations()
         .disableModuleScanning()
         .enableClassInfo()
         .scan().use { scanResult ->
             (scanResult.getClassesImplementing(GenericEvent::class.java) + scanResult.getClassesImplementing(BGenericEvent::class.java)).associate { info ->
-                info.loadClass().kotlin to Collections.unmodifiableList(info.subclasses.map { subclassInfo -> subclassInfo.loadClass().kotlin })
+                info.loadClass() to Collections.unmodifiableList(info.subclasses.map { subclassInfo -> subclassInfo.loadClass() })
             }
         }
 
-    internal fun getSubclasses(kClass: KClass<*>): List<KClass<*>> = map[kClass] ?: emptyList<KClass<*>>().also {
-        logger.warn { "Unknown event type: ${kClass.jvmName}" }
+    internal fun getSubclasses(clazz: Class<*>): List<Class<*>> = map[clazz] ?: emptyList<Class<*>>().also {
+        logger.warn { "Unknown event type: ${clazz.name}" }
     }
-}
+}

BotCommands-core/src/test/kotlin/io/github/freya022/botcommands/core/hooks/EventDispatcherTests.kt

@@ -40,7 +40,7 @@ object EventDispatcherTests {
         val expectedInstance = ReadyTestListener()
         val expectedFunction = ReadyTestListener::onReady
         val listenerRegistry = mockk<EventListenerRegistry> {
-            every { get(BReadyEvent::class) } returns mockk<EventListenerList> {
+            every { get(BReadyEvent::class.java) } returns mockk<EventListenerList> {
                 every { get(any<BEventListener.RunMode>()) } returns emptyList()
                 every { get(BEventListener.RunMode.BLOCKING) } returns listOf(
                     EventHandlerFunction(