chore: Cleanup error messages when reloading a module

Signed-off-by: Danielle Voznyy <dan.voznyy@gmail.com>

Author: 0ffz

core/src/commonMain/kotlin/com/mineinabyss/dependencies/DIAware.kt

@@ -2,6 +2,7 @@ package com.mineinabyss.dependencies
 
 import co.touchlab.kermit.Logger
 import com.mineinabyss.dependencies.exceptions.DIBindingException
+import com.mineinabyss.dependencies.exceptions.LoadResult
 import com.mineinabyss.dependencies.impl.MutableDIImpl
 import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.InvocationKind
@@ -16,7 +17,7 @@ import kotlin.reflect.typeOf
  * @see DIContext
  * @see MutableDI
  */
-@FeatureDSLMarker
+@DependenciesDSLMarker
 interface DI : AutoCloseable {
     val di: DIContext
 
@@ -58,7 +59,7 @@ interface DI : AutoCloseable {
 
         fun load(module: Module): DI
         fun unload(module: Module)
-        fun reload(module: Module)
+        fun reload(module: Module): LoadResult
 
         val loaded: List<Module>
     }

core/src/commonMain/kotlin/com/mineinabyss/dependencies/DIScope.kt

@@ -1,6 +1,7 @@
 package com.mineinabyss.dependencies
 
 import co.touchlab.kermit.Logger
+import com.mineinabyss.dependencies.exceptions.LoadResult
 
 class DIScope(root: MutableDI.() -> Unit = {}) : DI.Scope, DI, AutoCloseable {
     private val _loaded = mutableMapOf<DI.Module.Key, DI>()
@@ -35,51 +36,62 @@ class DIScope(root: MutableDI.() -> Unit = {}) : DI.Scope, DI, AutoCloseable {
         created.addCloseable {
             _loaded.remove(key)
             loadOrder.remove(module)
-            logger.i { "Unloaded feature $module" }
+            logger.i { "Unloaded module $module" }
         }
-        logger.i { "Loaded feature $module" }
+        logger.i { "Loaded module $module" }
         return created
     }
 
     fun loadAll(vararg modules: DI.Module) {
         modules.forEach { load(it) }
     }
 
-    override fun reload(module: DI.Module) {
+    override fun reload(module: DI.Module): LoadResult {
         val beforeUnload = loadOrder.toList()
         unload(module)
         val unloadedDependencies = beforeUnload.minus(loadOrder.toSet())
-        loadAll(*unloadedDependencies.toTypedArray())
+        return loadAllCatching(*unloadedDependencies.toTypedArray())
     }
 
-    fun reload(vararg module: DI.Module) {
+    fun reload(vararg module: DI.Module): LoadResult {
         val beforeUnload = loadOrder.toList()
         module.forEach { unload(it) }
         val unloadedDependencies = beforeUnload.minus(loadOrder.toSet())
-        loadAll(*unloadedDependencies.toTypedArray())
+        return loadAllCatching(*unloadedDependencies.toTypedArray())
     }
 
-    fun reloadAll() {
+    fun reloadAll(): LoadResult {
         val load = loadOrder.toTypedArray()
         unloadAll()
-        loadAll(*load)
+        return loadAllCatching(*load)
     }
 
-    operator fun get(module: DI.Module): DI? {
-        return _loaded[module.key]?.di
+    fun getOrNull(module: DI.Module): DI? {
+        return _loaded[module.key]?.takeIf { it != FailedModule }?.di
     }
 
-    operator fun <T> get(module: DI.ModuleWithConfig<T>): T? {
-        return _loaded[module.key]?.di?.let { module.get(it) }
+    fun <T> getOrNull(module: DI.ModuleWithConfig<T>): T? {
+        return _loaded[module.key]?.takeIf { it != FailedModule }?.di?.let { module.get(it) }
+    }
+
+    operator fun get(module: DI.Module): DI {
+        return getOrNull(module) ?: error("Failed to get module ${module.name}")
+    }
+
+    operator fun <T> get(module: DI.ModuleWithConfig<T>): T {
+        return getOrNull(module) ?: error("Failed to get module ${module.name}")
     }
 
     override fun unload(module: DI.Module) {
         val key = module.key
         val feat = _loaded[key] ?: return
-        feat.close()
-        // Ensure removed in case of FailedModule
-        _loaded.remove(key)
-        loadOrder.remove(module)
+        try {
+            feat.close()
+        } finally {
+            // Ensure removed in case of FailedModule or error
+            _loaded.remove(key)
+            loadOrder.remove(module)
+        }
     }
 
     fun unloadAll() {
@@ -94,13 +106,18 @@ class DIScope(root: MutableDI.() -> Unit = {}) : DI.Scope, DI, AutoCloseable {
 fun DI.Scope.loadCatching(module: DI.Module): Result<DI> {
     return runCatching { load(module) }.onFailure {
         if (it is IllegalArgumentException) {
-            logger.e { "Failed to load feature $module: ${it.message}" }
+            logger.e { "Failed to load module ${module.name}: ${it.message}" }
         } else {
-            logger.e(it) { "Failed to load feature $module" }
+            logger.e(it) { "Failed to load module ${module.name}" }
         }
     }
 }
 
-fun DI.Scope.loadAllCatching(vararg modules: DI.Module) {
-    modules.forEach { loadCatching(it) }
+/**
+ * Loads passed [modules] and their dependencies, printing error messages instead of throwing them when any fail to load.
+ *
+ * @return Whether all modules successfully loaded
+ */
+fun DI.Scope.loadAllCatching(vararg modules: DI.Module): LoadResult {
+    return LoadResult(modules.associateWith { loadCatching(it) })
 }

…m/mineinabyss/dependencies/FeatureDSL.kt …ss/dependencies/DependenciesDSLMarker.ktcore/src/commonMain/kotlin/com/mineinabyss/dependencies/FeatureDSL.kt renamed to core/src/commonMain/kotlin/com/mineinabyss/dependencies/DependenciesDSLMarker.kt core/src/commonMain/kotlin/com/mineinabyss/dependencies/FeatureDSL.kt renamed to core/src/commonMain/kotlin/com/mineinabyss/dependencies/DependenciesDSLMarker.kt

@@ -1,4 +1,4 @@
 package com.mineinabyss.dependencies
 
 @DslMarker
-annotation class FeatureDSLMarker
+annotation class DependenciesDSLMarker

core/src/commonMain/kotlin/com/mineinabyss/dependencies/exceptions/LoadResult.kt

@@ -0,0 +1,9 @@
+package com.mineinabyss.dependencies.exceptions
+
+import com.mineinabyss.dependencies.DI
+
+class LoadResult(
+    val results: Map<DI.Module, Result<DI>>,
+) {
+    val isSuccess = results.values.all { it.isSuccess }
+}

core/src/commonMain/kotlin/com/mineinabyss/dependencies/impl/MutableDIImpl.kt

@@ -33,9 +33,9 @@ class MutableDIImpl(
         return _injected[type] as? InjectedValue<T> ?: throw DIBindingException.of(type, null)
     }
 
-
     override fun singleModule(di: DI.Module): DI {
-        val loaded = scope.load(di)
+        val loaded = scope.loadCatching(di).getOrNull()
+        if (loaded == null || loaded == FailedModule) throw IllegalArgumentException("Depends on module [${di.name}] which failed to load.")
         if (di in dependsOn) return loaded
         dependsOn += di
         loaded.addCloseable { this@MutableDIImpl.close() }