Renderer bindings for Metro

Create a `Renderer` dependency graph for Metro and combine it with the `Renderer` component from kotlin-inject. This allows for an easier migration from kotlin-inject to Metro and eventually mixing both dependency injection frameworks if needed.

See #119

Author: vRallev

di-common/public/src/commonMain/kotlin/software/amazon/app/platform/inject/ContributesRenderer.kt

@@ -12,7 +12,7 @@ import software.amazon.lastmile.kotlin.inject.anvil.extend.ContributingAnnotatio
  * class IncrementRenderer : Renderer<IncrementPresenter.Model>()
  * ```
  *
- * This annotation would generated following component interface:
+ * This annotation would generated following component interface for kotlin-inject:
  * ```
  * @ContributesTo(RendererScope::class)
  * interface IncrementRendererComponent {
@@ -27,29 +27,33 @@ import software.amazon.lastmile.kotlin.inject.anvil.extend.ContributingAnnotatio
  * }
  * ```
  *
+ * Or following graph for Metro:
+ * ```
+ * @ContributesTo(RendererScope::class)
+ * interface IncrementRendererGraph {
+ *     @Provides
+ *     @IntoMap
+ *     @RendererKey(IncrementPresenter.Model::class)
+ *     fun provideIncrementRendererIncrementPresenterModel(
+ *         renderer: Provider<IncrementRenderer>,
+ *     ): Renderer<*> = renderer()
+ *
+ *     @Provides
+ *     fun provideIncrementRenderer(): IncrementRenderer = IncrementRenderer()
+ * }
+ * ```
+ *
  * Although strongly discouraged, your renderer is allowed to have an `@Inject constructor`. The
- * only valid use case is for injecting other renderers.
+ * only valid use case is for injecting other renderers returned by the `RendererFactory`.
  *
  * ```
  * @Inject
  * @ContributesRenderer
  * class IncrementRenderer(
- *     private val otherRenderer: OtherRenderer
+ *     private val rendererFactory: RendererFactory
  * ) : Renderer<IncrementPresenter.Model>() {
  * ```
  *
- * In this case following module would be generated:
- * ```
- * @ContributesTo(RendererScope::class)
- * abstract class IncrementRendererModule {
- *     @Provides
- *     @IntoMap
- *     fun provideIncrementRendererIntoMap(
- *         renderer: () -> IncrementRenderer,
- *     ): Pair<KClass<out BaseModel>, () -> Renderer<*>> = IncrementRenderer.Model::class to renderer
- * }
- * ```
- *
  * If the model type is a sealed hierarchy, then for each explicit type a binding method will be
  * generated.
  */

metro-extensions/contribute/impl-code-generators/src/test/kotlin/software/amazon/app/platform/inject/metro/CommonSourceCode.kt

@@ -4,16 +4,16 @@ package software.amazon.app.platform.inject.metro
 
 import com.tschuchort.compiletesting.JvmCompilationResult
 import org.jetbrains.kotlin.compiler.plugin.ExperimentalCompilerApi
-import software.amazon.test.TestRendererComponent
+import software.amazon.test.TestRendererGraph
 
 internal val JvmCompilationResult.graphInterface: Class<*>
   get() = classLoader.loadClass("software.amazon.test.GraphInterface")
 
-internal fun Class<*>.newTestRendererComponent(): TestRendererComponent {
+internal fun Class<*>.newTestRendererGraph(): TestRendererGraph {
   val companionObject = fields.single().get(null)
   return classes
     .single { it.simpleName == "Companion" }
     .declaredMethods
     .single { it.name == "create" }
-    .invoke(companionObject) as TestRendererComponent
+    .invoke(companionObject) as TestRendererGraph
 }

metro-extensions/contribute/impl-code-generators/src/test/kotlin/software/amazon/app/platform/inject/metro/processor/ContributesRendererProcessorTest.kt

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.compiler.plugin.ExperimentalCompilerApi
 import org.junit.jupiter.api.Test
 import software.amazon.app.platform.inject.metro.compile
 import software.amazon.app.platform.inject.metro.graphInterface
-import software.amazon.app.platform.inject.metro.newTestRendererComponent
+import software.amazon.app.platform.inject.metro.newTestRendererGraph
 import software.amazon.app.platform.ksp.inner
 import software.amazon.app.platform.ksp.isAnnotatedWith
 import software.amazon.app.platform.metro.METRO_LOOKUP_PACKAGE
@@ -90,12 +90,12 @@ class ContributesRendererProcessorTest {
         assertThat(getAnnotation(RendererKey::class.java).value).isEqualTo(model)
       }
 
-      assertThat(graphInterface.newTestRendererComponent().renderers.keys).containsOnly(model)
+      assertThat(graphInterface.newTestRendererGraph().renderers.keys).containsOnly(model)
 
-      assertThat(graphInterface.newTestRendererComponent().modelToRendererMapping.keys)
+      assertThat(graphInterface.newTestRendererGraph().modelToRendererMapping.keys)
         .containsOnly(model)
 
-      assertThat(graphInterface.newTestRendererComponent().modelToRendererMapping.values)
+      assertThat(graphInterface.newTestRendererGraph().modelToRendererMapping.values)
         .containsOnly(testRenderer.kotlin)
     }
   }
@@ -148,7 +148,7 @@ class ContributesRendererProcessorTest {
         assertThat(getAnnotation(RendererKey::class.java).value).isEqualTo(model)
       }
 
-      assertThat(graphInterface.newTestRendererComponent().renderers.keys).containsOnly(model)
+      assertThat(graphInterface.newTestRendererGraph().renderers.keys).containsOnly(model)
     }
   }
 
@@ -197,7 +197,7 @@ class ContributesRendererProcessorTest {
         assertThat(this).isAnnotatedWith(IntoMap::class)
       }
 
-      assertThat(graphInterface.newTestRendererComponent().renderers.keys)
+      assertThat(graphInterface.newTestRendererGraph().renderers.keys)
         .containsOnly(presenter.model.kotlin)
     }
   }
@@ -222,7 +222,7 @@ class ContributesRendererProcessorTest {
       """,
       graphInterfaceSource,
     ) {
-      assertThat(graphInterface.newTestRendererComponent().renderers.keys).containsOnly(model)
+      assertThat(graphInterface.newTestRendererGraph().renderers.keys).containsOnly(model)
     }
   }
 
@@ -371,7 +371,7 @@ class ContributesRendererProcessorTest {
         assertThat(it).isAnnotatedWith(RendererKey::class)
       }
 
-      assertThat(graphInterface.newTestRendererComponent().renderers.keys)
+      assertThat(graphInterface.newTestRendererGraph().renderers.keys)
         .containsExactlyInAnyOrder(
           presenter.model.kotlin,
           presenter.model.inner.kotlin,
@@ -402,7 +402,7 @@ class ContributesRendererProcessorTest {
         assertThat(it).isAnnotatedWith(ForScope::class)
       }
 
-      assertThat(graphInterface.newTestRendererComponent().modelToRendererMapping.keys)
+      assertThat(graphInterface.newTestRendererGraph().modelToRendererMapping.keys)
         .containsExactlyInAnyOrder(
           presenter.model.kotlin,
           presenter.model.inner.kotlin,
@@ -411,7 +411,7 @@ class ContributesRendererProcessorTest {
           presenter.model.model2.kotlin,
         )
 
-      assertThat(graphInterface.newTestRendererComponent().modelToRendererMapping.values.distinct())
+      assertThat(graphInterface.newTestRendererGraph().modelToRendererMapping.values.distinct())
         .containsOnly(testRenderer.kotlin)
     }
   }
@@ -459,13 +459,13 @@ class ContributesRendererProcessorTest {
         )
         .containsOnly("provideSoftwareAmazonTestTestRendererPresenterModelKey")
 
-      assertThat(graphInterface.newTestRendererComponent().renderers.keys)
+      assertThat(graphInterface.newTestRendererGraph().renderers.keys)
         .containsOnly(presenter.model.kotlin)
 
-      assertThat(graphInterface.newTestRendererComponent().modelToRendererMapping.keys)
+      assertThat(graphInterface.newTestRendererGraph().modelToRendererMapping.keys)
         .containsOnly(presenter.model.kotlin)
 
-      assertThat(graphInterface.newTestRendererComponent().modelToRendererMapping.values)
+      assertThat(graphInterface.newTestRendererGraph().modelToRendererMapping.values)
         .containsOnly(testRenderer.kotlin)
     }
   }
@@ -501,7 +501,7 @@ class ContributesRendererProcessorTest {
           "provideSoftwareAmazonTestTestRendererModelKey",
         )
 
-      assertThat(graphInterface.newTestRendererComponent().renderers.keys).containsOnly(model)
+      assertThat(graphInterface.newTestRendererGraph().renderers.keys).containsOnly(model)
     }
   }
 
@@ -613,11 +613,11 @@ class ContributesRendererProcessorTest {
         import dev.zacsweers.metro.Provider
         import dev.zacsweers.metro.Provides
         import dev.zacsweers.metro.SingleIn
-        import software.amazon.test.TestRendererComponent
+        import software.amazon.test.TestRendererGraph
 
         @DependencyGraph(RendererScope::class)
         @SingleIn(RendererScope::class)
-        interface GraphInterface : TestRendererComponent {
+        interface GraphInterface : TestRendererGraph {
             @Provides fun provideString(): String = "abc"
 
             companion object {

metro-extensions/contribute/impl-code-generators/src/test/kotlin/software/amazon/test/TestRendererComponent.kt renamed to metro-extensions/contribute/impl-code-generators/src/test/kotlin/software/amazon/test/TestRendererGraph.kt

@@ -7,7 +7,7 @@ import software.amazon.app.platform.presenter.BaseModel
 import software.amazon.app.platform.renderer.Renderer
 import software.amazon.app.platform.renderer.RendererScope
 
-interface TestRendererComponent {
+interface TestRendererGraph {
   val renderers: Map<KClass<out BaseModel>, Provider<Renderer<*>>>
 
   @ForScope(RendererScope::class)

renderer/public/api/android/public.api

@@ -1,3 +1,7 @@
+public final class metro/hints/SoftwareAmazonAppPlatformRendererRendererGraphFactoryAppScopeKt {
+	public static final fun AppScope (Lsoftware/amazon/app/platform/renderer/RendererGraph$Factory;)V
+}
+
 public class software/amazon/app/platform/renderer/BaseRendererFactory : software/amazon/app/platform/renderer/RendererFactory {
 	public fun <init> (Lsoftware/amazon/app/platform/scope/RootScopeProvider;)V
 	public fun createRenderer (Lkotlin/reflect/KClass;)Lsoftware/amazon/app/platform/renderer/Renderer;
@@ -33,6 +37,18 @@ public final class software/amazon/app/platform/renderer/RendererFactoryKt {
 	public static synthetic fun getRenderer$default (Lsoftware/amazon/app/platform/renderer/RendererFactory;Lsoftware/amazon/app/platform/presenter/BaseModel;IILjava/lang/Object;)Lsoftware/amazon/app/platform/renderer/Renderer;
 }
 
+public abstract interface class software/amazon/app/platform/renderer/RendererGraph {
+	public abstract fun getModelToRendererMapping ()Ljava/util/Map;
+	public abstract fun getRenderers ()Ljava/util/Map;
+}
+
+public abstract interface class software/amazon/app/platform/renderer/RendererGraph$Factory {
+	public abstract fun createRendererGraph (Lsoftware/amazon/app/platform/renderer/RendererFactory;)Lsoftware/amazon/app/platform/renderer/RendererGraph;
+}
+
+public abstract interface class software/amazon/app/platform/renderer/RendererGraph$Factory$$$MetroContributionToAppScope : software/amazon/app/platform/renderer/RendererGraph$Factory {
+}
+
 public abstract class software/amazon/app/platform/renderer/RendererScope {
 }
 

renderer/public/api/desktop/public.api

@@ -1,3 +1,7 @@
+public final class metro/hints/SoftwareAmazonAppPlatformRendererRendererGraphFactoryAppScopeKt {
+	public static final fun AppScope (Lsoftware/amazon/app/platform/renderer/RendererGraph$Factory;)V
+}
+
 public class software/amazon/app/platform/renderer/BaseRendererFactory : software/amazon/app/platform/renderer/RendererFactory {
 	public fun <init> (Lsoftware/amazon/app/platform/scope/RootScopeProvider;)V
 	public fun createRenderer (Lkotlin/reflect/KClass;)Lsoftware/amazon/app/platform/renderer/Renderer;
@@ -33,6 +37,18 @@ public final class software/amazon/app/platform/renderer/RendererFactoryKt {
 	public static synthetic fun getRenderer$default (Lsoftware/amazon/app/platform/renderer/RendererFactory;Lsoftware/amazon/app/platform/presenter/BaseModel;IILjava/lang/Object;)Lsoftware/amazon/app/platform/renderer/Renderer;
 }
 
+public abstract interface class software/amazon/app/platform/renderer/RendererGraph {
+	public abstract fun getModelToRendererMapping ()Ljava/util/Map;
+	public abstract fun getRenderers ()Ljava/util/Map;
+}
+
+public abstract interface class software/amazon/app/platform/renderer/RendererGraph$Factory {
+	public abstract fun createRendererGraph (Lsoftware/amazon/app/platform/renderer/RendererFactory;)Lsoftware/amazon/app/platform/renderer/RendererGraph;
+}
+
+public abstract interface class software/amazon/app/platform/renderer/RendererGraph$Factory$$$MetroContributionToAppScope : software/amazon/app/platform/renderer/RendererGraph$Factory {
+}
+
 public abstract class software/amazon/app/platform/renderer/RendererScope {
 }
 

renderer/public/build.gradle

@@ -4,6 +4,7 @@ plugins {
 
 appPlatformBuildSrc {
     enableKotlinInject true
+    enableMetro true
     enablePublishing true
 }
 

renderer/public/src/commonMain/kotlin/software/amazon/app/platform/renderer/BaseRendererFactory.kt

@@ -5,7 +5,9 @@ import kotlinx.atomicfu.locks.SynchronizedObject
 import kotlinx.atomicfu.locks.synchronized
 import software.amazon.app.platform.presenter.BaseModel
 import software.amazon.app.platform.scope.RootScopeProvider
+import software.amazon.app.platform.scope.Scope
 import software.amazon.app.platform.scope.di.kotlinInjectComponent
+import software.amazon.app.platform.scope.di.metro.metroDependencyGraph
 
 /**
  * Default implementation for [RendererFactory]. Implementations usually override [createRenderer]
@@ -15,13 +17,21 @@ public open class BaseRendererFactory(rootScopeProvider: RootScopeProvider) : Re
 
   private val rendererComponent =
     rootScopeProvider.rootScope
-      .kotlinInjectComponent<RendererComponent.Parent>()
-      .rendererComponent(this)
+      .kotlinInjectComponentOrNull<RendererComponent.Parent>()
+      ?.rendererComponent(this)
 
-  private val renderers: Map<KClass<out BaseModel>, () -> Renderer<*>> = rendererComponent.renderers
+  private val rendererGraph =
+    rootScopeProvider.rootScope
+      .metroDependencyGraphOrNull<RendererGraph.Factory>()
+      ?.createRendererGraph(this)
+
+  private val renderers: Map<KClass<out BaseModel>, () -> Renderer<*>> =
+    rendererComponent?.renderers.orEmpty() +
+      rendererGraph?.renderers.orEmpty().mapValues { { it.value() } }
 
   private val cacheKeys: Map<KClass<out BaseModel>, KClass<out Renderer<*>>> =
-    rendererComponent.modelToRendererMapping
+    rendererComponent?.modelToRendererMapping.orEmpty() +
+      rendererGraph?.modelToRendererMapping.orEmpty()
 
   private val rendererCache = mutableMapOf<CacheKey, Renderer<*>>()
   private val lock = SynchronizedObject()
@@ -52,4 +62,22 @@ public open class BaseRendererFactory(rootScopeProvider: RootScopeProvider) : Re
   }
 
   private data class CacheKey(val clazz: KClass<out Renderer<*>>, val rendererId: Int)
+
+  private companion object {
+    inline fun <reified T : Any> Scope.metroDependencyGraphOrNull(): T? {
+      return try {
+        metroDependencyGraph<T>()
+      } catch (_: NoSuchElementException) {
+        null
+      }
+    }
+
+    inline fun <reified T : Any> Scope.kotlinInjectComponentOrNull(): T? {
+      return try {
+        kotlinInjectComponent<T>()
+      } catch (_: NoSuchElementException) {
+        null
+      }
+    }
+  }
 }

renderer/public/src/commonMain/kotlin/software/amazon/app/platform/renderer/RendererComponent.kt

@@ -7,7 +7,7 @@ import software.amazon.lastmile.kotlin.inject.anvil.ContributesSubcomponent
 import software.amazon.lastmile.kotlin.inject.anvil.ForScope
 import software.amazon.lastmile.kotlin.inject.anvil.SingleIn
 
-/** Component that provides all [Renderer] instance from the dependency graph. */
+/** Component that provides all [Renderer] instance from the kotlin-inject dependency graph. */
 @ContributesSubcomponent(RendererScope::class)
 @SingleIn(RendererScope::class)
 public interface RendererComponent {

renderer/public/src/commonMain/kotlin/software/amazon/app/platform/renderer/RendererGraph.kt

@@ -0,0 +1,40 @@
+package software.amazon.app.platform.renderer
+
+import dev.zacsweers.metro.AppScope
+import dev.zacsweers.metro.ContributesTo
+import dev.zacsweers.metro.ForScope
+import dev.zacsweers.metro.GraphExtension
+import dev.zacsweers.metro.Provider
+import dev.zacsweers.metro.Provides
+import dev.zacsweers.metro.SingleIn
+import kotlin.reflect.KClass
+import software.amazon.app.platform.presenter.BaseModel
+
+/** Graph that provides all [Renderer] instance from the Metro dependency graph. */
+@GraphExtension(RendererScope::class)
+@SingleIn(RendererScope::class)
+public interface RendererGraph {
+  /** All [Renderer]s provided in the dependency graph. */
+  public val renderers: Map<KClass<out BaseModel>, Provider<Renderer<*>>>
+
+  /**
+   * [RendererFactory]s cache renderers based on the model type. This works well, when there's a one
+   * to one relationship between a model type and a renderer. However, for sealed hierarchies there
+   * are multiple model types pointing to the same renderer.
+   *
+   * This map, given any model type as key, returns the type that should be used as key for caching.
+   * For non-sealed hierarchies (aka a single model type per renderer) there is only single mapping
+   * between the model and renderer class. For sealed hierarchies there are multiple entries with
+   * all keys pointing to the same renderer class.
+   */
+  @ForScope(RendererScope::class)
+  public val modelToRendererMapping: Map<KClass<out BaseModel>, KClass<out Renderer<*>>>
+
+  /** The parent interface to create a [RendererGraph]. */
+  @ContributesTo(AppScope::class)
+  @GraphExtension.Factory
+  public interface Factory {
+    /** Creates a new [RendererGraph]. */
+    public fun createRendererGraph(@Provides factory: RendererFactory): RendererGraph
+  }
+}