Extending kotlin-inject for fun & profit

Kotlin-inject is a dependency injection framework for Kotlin Multiplatform. It verifies the dependency graph during compilaton and generates the necessary code to instantiate the object graph at runtime. It offers a similar feature set as Dagger 2 without the limitation of being tied to the JVM and Android only.

This talk will offer a short introduction to kotlin-inject and discuss its benefits and downsides and how the framework scales in large, modularized code bases. To close some of the gaps and solve project specific use cases KSP and custom code generators will be used to extend the framework and to give us features similar to the ones Anvil provides for Dagger 2. These practical examples serve as an introduction and blueprint into the meta-programming world to reduce boilerplate and simplify patterns in your code base.

Transcript

1. Extending kotlin-inject for fun & profit September 20th, 2024 Ralf Wondratschek
2. https://www.youtube.com/watch?v=xESX82kwjn4
4. https://www.youtube.com/watch?v=0T_zvUEqsD4
5. Background https://ralf-wondratschek.com/presentations
6. Background • We like Dagger 2 for its many benefits • We like Anvil for its simplicity • But both don’t work with KMP in common code
7. Dagger 2 Provider side Component Injection side
8. interface WeatherRepository { fun provideForecast(location: Location): Forecast } Dagger 2
9. Dagger 2 interface WeatherRepository { fun provideForecast(location: Location): Forecast } class WeatherRepositoryImpl( client: HttpClient, ) : WeatherRepository { ... }
10. Dagger 2 interface WeatherRepository { fun provideForecast(location: Location): Forecast } class WeatherRepositoryImpl( client: HttpClient, ) : WeatherRepository { ... } @Module object WeatherRepositoryModule { @Provides @Singleton fun provideWeatherRepository(client: HttpClient): WeatherRepository { return WeatherRepositoryImpl(client) } }
11. Dagger 2 interface WeatherRepository { fun provideForecast(location: Location): Forecast } class WeatherRepositoryImpl( client: HttpClient, ) : WeatherRepository { ... } @Module object WeatherRepositoryModule { @Provides @Singleton fun provideWeatherRepository(client: HttpClient): WeatherRepository { return WeatherRepositoryImpl(client) } }
12. Dagger 2 interface WeatherRepository { fun provideForecast(location: Location): Forecast } class WeatherRepositoryImpl( client: HttpClient, ) : WeatherRepository { ... } @Module object WeatherRepositoryModule { @Provides @Singleton fun provideWeatherRepository(client: HttpClient): WeatherRepository { return WeatherRepositoryImpl(client) } }
13. Dagger 2 @Singleton @Component( modules = [ WeatherRepositoryModule::class, ] ) interface AppComponent
14. Dagger 2 @Singleton @Component( modules = [ WeatherRepositoryModule::class, ] ) interface AppComponent
15. @Component( modules = [ WeatherRepositoryModule::class, ] ) interface AppComponent Dagger 2
16. Dagger 2 @Singleton @Component( modules = [ WeatherRepositoryModule::class, ] ) interface AppComponent
17. Dagger 2 @Singleton @Component( modules = [ WeatherRepositoryModule::class, ] ) interface AppComponent val appComponent = DaggerAppComponent.create()
18. Dagger 2 @Singleton @Component( modules = [ WeatherRepositoryModule::class, ] ) interface AppComponent { fun weatherRepository(): WeatherRepository } val appComponent = DaggerAppComponent.create() val weatherRepository = appComponent.weatherRepository()
19. Dagger 2 @Singleton @Component( modules = [ WeatherRepositoryModule::class, ] ) interface AppComponent { fun weatherRepository(): WeatherRepository } val appComponent = DaggerAppComponent.create() val weatherRepository = appComponent.weatherRepository()
20. Dagger 2 class WeatherRepositoryImpl( client: HttpClient, ) : WeatherRepository { ... } @Module object WeatherRepositoryModule { @Provides @Singleton fun provideWeatherRepository(client: HttpClient): WeatherRepository { return WeatherRepositoryImpl(client) } }
21. Dagger 2 @Singleton class WeatherRepositoryImpl @Inject constructor( client: HttpClient, ) : WeatherRepository @Module object WeatherRepositoryModule { @Provides @Singleton fun provideWeatherRepository(client: HttpClient): WeatherRepository { return WeatherRepositoryImpl(client) } }
22. Dagger 2 @Singleton class WeatherRepositoryImpl @Inject constructor( client: HttpClient, ) : WeatherRepository @Module object WeatherRepositoryModule { @Provides @Singleton fun provideWeatherRepository(client: HttpClient): WeatherRepository { return WeatherRepositoryImpl(client) } }
23. Dagger 2 @Singleton class WeatherRepositoryImpl @Inject constructor( client: HttpClient, ) : WeatherRepository @Module interface WeatherRepositoryModule { @Binds fun bindWeatherRepository( weatherRepositoryImpl: WeatherRepositoryImpl ): WeatherRepository }
24. Dagger 2 :app AppComponent :weather WeatherRepositoryModule
25. Dagger 2 :app AppComponent :weather WeatherRepositoryModule :forecast appComponent.weatherRepository()
26. Dagger 2 :app AppComponent :weather WeatherRepositoryModule :forecast appComponent.weatherRepository()
27. Dagger 2 @Singleton @Component( modules = [ WeatherRepositoryModule::class, ] ) interface AppComponent { fun weatherRepository(): WeatherRepository }
28. Dagger 2 interface WeatherComponent { fun weatherRepository(): WeatherRepository } @Singleton @Component( modules = [ WeatherRepositoryModule::class, ] ) interface AppComponent : WeatherComponent
29. Dagger 2 :app AppComponent :weather WeatherRepositoryModule :forecast appComponent.weatherRepository()
30. Dagger 2 :app AppComponent :weather WeatherRepositoryModule :forecast WeatherComponent
31. Anvil
32. Anvil https://ralf-wondratschek.com/presentations
33. Anvil object AppScope @Contributes*(AppScope::class) @MergeComponent(AppScope::class)
34. Dagger 2 @Singleton class WeatherRepositoryImpl @Inject constructor( client: HttpClient, ) : WeatherRepository @Module interface WeatherRepositoryModule { @Binds fun bindWeatherRepository( weatherRepositoryImpl: WeatherRepositoryImpl ): WeatherRepository }
35. Anvil @Singleton class WeatherRepositoryImpl @Inject constructor( client: HttpClient, ) : WeatherRepository @Module @ContributesTo(AppScope::class) interface WeatherRepositoryModule { @Binds fun bindWeatherRepository( weatherRepositoryImpl: WeatherRepositoryImpl ): WeatherRepository }
36. Anvil @Singleton @ContributesBinding(AppScope::class) class WeatherRepositoryImpl @Inject constructor( client: HttpClient, ) : WeatherRepository @Module @ContributesTo(AppScope::class) interface WeatherRepositoryModule { @Binds fun bindWeatherRepository( weatherRepositoryImpl: WeatherRepositoryImpl ): WeatherRepository }
37. Anvil @Singleton @ContributesBinding(AppScope::class) class WeatherRepositoryImpl @Inject constructor( client: HttpClient, ) : WeatherRepository
38. Dagger 2 interface WeatherComponent { fun weatherRepository(): WeatherRepository }
39. Anvil @ContributesTo(AppScope::class) interface WeatherComponent { fun weatherRepository(): WeatherRepository }
40. Dagger 2 @Singleton @Component( modules = [ WeatherRepositoryModule::class, ] ) interface AppComponent : WeatherComponent
41. Anvil @Singleton @MergeComponent( scope = AppScope::class, modules = [ WeatherRepositoryModule::class, ] ) interface AppComponent : WeatherComponent
42. Anvil @Singleton @MergeComponent( scope = AppScope::class, ) interface AppComponent : WeatherComponent
43. Anvil @Singleton @MergeComponent(AppScope::class) interface AppComponent : WeatherComponent
44. Anvil @Singleton @MergeComponent(AppScope::class) interface AppComponent
45. Anvil - Other benefits • Removes boilerplate • Aligns build graph with Gradle dependency graph • Improves build times significantly • Easy to replace bindings in tests • Extensible with custom code generators
46. kotlin-inject
47. “The Dagger 2 for Kotlin Multiplatform.”
48. kotlin-inject • Compile-time dependency injection framework for Kotlin • Architecture very similar to Dagger 2 • Similar feature set as Dagger 2: Provider methods, components, scopes, qualifiers, multi-bindings, assisted injection, lazy injection, … • Unique features: KMP support, uses KSP, no modules, no binding methods, override provider functions, function support, default arguments, …
49. kotlin-inject import me.tatarka.inject.annotations.* @Scope annotation class Singleton
50. Dagger 2 @Singleton class WeatherRepositoryImpl @Inject constructor( client: HttpClient, ) : WeatherRepository @Module interface WeatherRepositoryModule { @Binds fun bindWeatherRepository( weatherRepositoryImpl: WeatherRepositoryImpl ): WeatherRepository }
51. kotlin-inject @Singleton @Inject class WeatherRepositoryImpl( client: HttpClient, ) : WeatherRepository @Module interface WeatherRepositoryModule { @Binds fun bindWeatherRepository( weatherRepositoryImpl: WeatherRepositoryImpl ): WeatherRepository }
52. kotlin-inject @Singleton @Inject class WeatherRepositoryImpl( client: HttpClient, ) : WeatherRepository @Module interface WeatherRepositoryModule { @Binds fun bindWeatherRepository( weatherRepositoryImpl: WeatherRepositoryImpl ): WeatherRepository }
53. kotlin-inject @Singleton @Inject class WeatherRepositoryImpl( client: HttpClient, ) : WeatherRepository interface WeatherRepositoryComponent { @Provides fun provideWeatherRepository( weatherRepository: WeatherRepositoryImpl ): WeatherRepository = weatherRepository }
54. Dagger 2 @Singleton @Component( modules = [ WeatherRepositoryModule::class, ] ) interface AppComponent val appComponent = DaggerAppComponent.create()
55. kotlin-inject @Singleton @Component interface AppComponent : WeatherRepositoryComponent val appComponent = DaggerAppComponent.create()
56. Dagger 2 @Singleton @Component interface AppComponent : WeatherRepositoryComponent val appComponent = DaggerAppComponent.create()
57. kotlin-inject @Singleton @Component interface AppComponent : WeatherRepositoryComponent val appComponent = AppComponent::class.create()
58. kotlin-inject @Singleton @Component interface AppComponent : WeatherRepositoryComponent { val weatherRepository: WeatherRepository } val appComponent = AppComponent::class.create() val weatherRepository = appComponent.weatherRepository
59. kotlin-inject @Singleton @Component interface AppComponent : WeatherRepositoryComponent { val weatherRepository: WeatherRepository }
60. kotlin-inject interface WeatherComponent { val weatherRepository: WeatherRepository } @Singleton @Component interface AppComponent : WeatherRepositoryComponent, WeatherComponent
61. kotlin-inject :app AppComponent :weather WeatherRepositoryComponent :forecast WeatherComponent
62. kotlin-inject - the good Reduced API surface: Member injection @Binds @BindsInstance @Module @Subcomponent @Assisted @AssistedInject
63. kotlin-inject - the good Arguments: @Component abstract class AppComponent val appComponent = AppComponent::class.create()
64. kotlin-inject - the good Arguments: @Component abstract class AppComponent( @get:Provides val application: Application, ) val application = … val appComponent = AppComponent::class.create(application)
65. kotlin-inject - the good Component inheritance: @Component abstract class AppComponent @Component abstract class LoggedInComponent( @get:Provides val user: User, )
66. kotlin-inject - the good Component inheritance: @Component abstract class AppComponent @Component abstract class LoggedInComponent( @Component val appComponent: AppComponent, @get:Provides val user: User, )
67. kotlin-inject - the good Component inheritance: @Component abstract class AppComponent @Component abstract class LoggedInComponent( @Component val appComponent: AppComponent, @get:Provides val user: User, ) LoggedInComponent::class.create(appComponent, user)
68. kotlin-inject - the good Override functions @Component abstract class AppComponent @Component abstract class LoggedInComponent(...)
69. kotlin-inject - the good Override functions @Component abstract class AppComponent @Component abstract class LoggedInComponent(...) { interface Factory { fun loggedInComponent(user: User): LoggedInComponent } }
70. kotlin-inject - the good Override functions @Component abstract class AppComponent : LoggedInComponent.Factory { override fun loggedInComponent(user: User): LoggedInComponent { return LoggedInComponent::class.create(this, user) } } @Component abstract class LoggedInComponent(...) { interface Factory { fun loggedInComponent(user: User): LoggedInComponent } }
71. kotlin-inject - the good Kotlin support Lazy, default arguments, assisted injection, overridden functions, …
72. kotlin-inject - the good KAPT Stub generation (kotlinc)
73. kotlin-inject - the good KAPT Stub generation (kotlinc) KAPT
74. kotlin-inject - the good KAPT Stub generation (kotlinc) KAPT kotlinc
75. kotlin-inject - the good KAPT Stub generation (kotlinc) KAPT kotlinc javac
76. kotlin-inject - the good KSP KSP (kotlinc)
77. kotlin-inject - the good KSP KSP (kotlinc) kotlinc
78. kotlin-inject - the good
79. kotlin-inject - the good Scopes object AppScope object LoggedInScope @SingleIn(AppScope::class) @SingleIn(LoggedInScope::class)
80. kotlin-inject - the good Scopes @SingleInAppScope @SingleInLoggedInScope … https://github.com/evant/kotlin-inject/issues/377
81. kotlin-inject - the good Scopes @SingleInAppScope @SingleInLoggedInScope https://github.com/evant/kotlin-inject/issues/377
82. kotlin-inject - the good Qualifiers @ForScope(AppScope::class) @ForScope(LoggedInScope::class)
83. kotlin-inject - the good Qualifiers typealias AppScopeCoroutineScope = CoroutineScope typealias LoggedInScopeCoroutineScope = CoroutineScope typealias PresenterCoroutineScope = CoroutineScope … https://github.com/evant/kotlin-inject/issues/253
84. kotlin-inject - the good Qualifiers typealias AppScopeCoroutineScope = CoroutineScope typealias LoggedInScopeCoroutineScope = CoroutineScope typealias PresenterCoroutineScope = CoroutineScope … https://github.com/evant/kotlin-inject/issues/253
85. kotlin-inject - the bad No wide adoption Slightly slower at runtime Slow releases
86. kotlin-inject - best practices :app1 AppComponent, LoggedInComponent :weather WeatherRepositoryModule :forecast WeatherComponent
87. kotlin-inject - best practices :app1 AppComponent, LoggedInComponent :weather WeatherRepositoryModule :forecast WeatherComponent :app2 AppComponent, LoggedInComponent
88. kotlin-inject - best practices :app1 AppComponent, LoggedInComponent :weather WeatherRepositoryModule :forecast WeatherComponent :app2 AppComponent, LoggedInComponent :app3 AppComponent, LoggedInComponent
89. kotlin-inject - best practices Scopes: @Inject @Singleton class WeatherRepositoryImpl( client: HttpClient, ) : WeatherRepository
90. kotlin-inject - best practices Naming: interface WeatherRepositoryComponent { val weatherRepository: WeatherRepository @Provides fun provideWeatherRepository( weatherRepository: WeatherRepositoryImpl ): WeatherRepository = weatherRepository }
91. kotlin-inject - best practices Naming: interface ${descriptiveName}Component { val weatherRepository: WeatherRepository @Provides fun provide${returnType}( weatherRepository: WeatherRepositoryImpl ): WeatherRepository = weatherRepository }
92. kotlin-inject - best practices Naming: interface ${descriptiveName}Component { val weatherRepository: WeatherRepository @Provides fun provide${returnType}( weatherRepository: WeatherRepositoryImpl ): WeatherRepository = weatherRepository }
93. kotlin-inject - best practices Component interfaces as inner classes: abstract class ViewRenderer<T : BaseModel> : Renderer<T> { fun init(...) { val coroutineScope = CoroutineScope( rootScopeProvider.rootScope.diComponent<Component>().dispatcher + Job(), ) } interface Component { val dispatcher: MainCoroutineDispatcher } }
94. kotlin-inject - best practices Component interfaces as inner classes: abstract class ViewRenderer<T : BaseModel> : Renderer<T> { fun init(...) { val coroutineScope = CoroutineScope( rootScopeProvider.rootScope.diComponent<Component>().dispatcher + Job(), ) } interface Component { val dispatcher: MainCoroutineDispatcher } }
95. kotlin-inject - best practices Component per platform @Component abstract class AndroidAppComponent( @get:Provides val application: Application, ) : LoggedInComponent.Factory { override fun loggedInComponent(user: User): LoggedInComponent { return AndroidLoggedInComponent::class.create(this, user) } }
96. kotlin-inject - best practices Component per platform @Component abstract class AndroidAppComponent( @get:Provides val application: Application, ) : LoggedInComponent.Factory { override fun loggedInComponent(user: User): LoggedInComponent { return AndroidLoggedInComponent::class.create(this, user) } }
97. kotlin-inject - best practices Component per platform @Component abstract class IosAppComponent( @get:Provides val uiApplication: UIApplication, ) : LoggedInComponent.Factory { override fun loggedInComponent(user: User): LoggedInComponent { return IosLoggedInComponent::class.create(this, user) } }
98. kotlin-inject - best practices Component per platform @Component abstract class IosAppComponent( @get:Provides val uiApplication: UIApplication, ) : LoggedInComponent.Factory { override fun loggedInComponent(user: User): LoggedInComponent { return IosLoggedInComponent::class.create(this, user) } }
99. kotlin-inject - best practices Component per platform @Component abstract class DesktopAppComponent : LoggedInComponent.Factory { override fun loggedInComponent(user: User): LoggedInComponent { return DesktopLoggedInComponent::class.create(this, user) } }
100. kotlin-inject - best practices Component per platform interface LoggedInComponent( val appComponent: AppComponent val user: User ) @Component abstract class AndroidLoggedInComponent( @Component override val appComponent: AndroidAppComponent, @get:Provides override val user: User, ) : LoggedInComponent
101. kotlin-inject - best practices iOS @Component abstract class IosAppComponent( @get:Provides val iosNativeImplementations: IosNativeImplementations, ) : IosNativeImplementations.Component
102. kotlin-inject - best practices iOS interface IosNativeImplementations { val uiApplication: UIApplication interface Component { @Provides fun provideUiApplication( iosNativeImplementations: IosNativeImplementations ): UIApplication = iosNativeImplementations.uiApplication } }
103. kotlin-inject - boilerplate @Component abstract class AppComponent(...)
104. kotlin-inject - boilerplate @Component abstract class AppComponent(...) : Component1
105. kotlin-inject - boilerplate @Component abstract class AppComponent(...) : Component1, Component2
106. kotlin-inject - boilerplate @Component abstract class AppComponent(...) : Component1, Component2, Component3
107. kotlin-inject - boilerplate @Component abstract class AppComponent(...) : Component1, Component2, Component3, Component4
108. kotlin-inject - boilerplate @Component abstract class AppComponent(...) : Component1, Component2, Component3, Component4, Component5
109. kotlin-inject - boilerplate @Component abstract class AppComponent(...) : Component1, Component2, Component3, Component4, Component5, Component6
110. kotlin-inject - boilerplate @Component abstract class AppComponent(...) : Component1, Component2, Component3, Component4, Component5, Component6, Component7
111. kotlin-inject - boilerplate @Component abstract class AppComponent(...) : Component1, Component2, Component3, Component4, Component5, Component6, Component7, Component8
112. kotlin-inject - boilerplate @Component abstract class AppComponent(...) : Component1, Component2, Component3, Component4, Component5, Component6, Component7, Component8, Component9
113. kotlin-inject - boilerplate @Component abstract class AppComponent(...) : Component1, Component2, Component3, Component4, Component5, Component6, Component7, Component8, Component9, …
114. kotlin-inject - boilerplate interface NewComponent { … }
115. kotlin-inject - boilerplate interface NewComponent { … } @Component abstract class AndroidApp1Component : NewComponent
116. kotlin-inject - boilerplate interface NewComponent { … } @Component abstract class AndroidApp1Component : NewComponent @Component abstract class AndroidApp2Component : NewComponent
117. kotlin-inject - boilerplate interface NewComponent { … } @Component abstract class AndroidApp1Component : NewComponent @Component abstract class AndroidApp2Component : NewComponent @Component abstract class DemoAppComponent : NewComponent
118. kotlin-inject - boilerplate interface NewComponent { … } @Component abstract class AndroidApp1Component : NewComponent @Component abstract class AndroidApp2Component : NewComponent @Component abstract class DemoAppComponent : NewComponent @Component abstract class IosAppComponent : NewComponent
119. kotlin-inject - boilerplate interface NewComponent { … } @Component abstract class AndroidApp1Component : NewComponent @Component abstract class AndroidApp2Component : NewComponent @Component abstract class DemoAppComponent : NewComponent @Component abstract class IosAppComponent : NewComponent @Component abstract class DesktopAppComponent : NewComponent …
120. kotlin-inject - boilerplate We really miss Anvil …
121. kotlin-inject-anvil https://github.com/amzn/kotlin-inject-anvil
122. kotlin-inject @Inject @Singleton class WeatherRepositoryImpl( client: HttpClient, ) : WeatherRepository interface WeatherRepositoryComponent { @Provides fun provideWeatherRepository( weatherRepository: WeatherRepositoryImpl ): WeatherRepository = weatherRepository }
123. kotlin-inject-anvil @ContributesBinding(AppScope::class) @Inject @Singleton class WeatherRepositoryImpl( client: HttpClient, ) : WeatherRepository interface WeatherRepositoryComponent { @Provides fun provideWeatherRepository( weatherRepository: WeatherRepositoryImpl ): WeatherRepository = weatherRepository }
124. kotlin-inject-anvil @ContributesBinding(AppScope::class) @Inject @Singleton class WeatherRepositoryImpl( client: HttpClient, ) : WeatherRepository
125. kotlin-inject interface WeatherComponent { val weatherRepository: WeatherRepository } @Singleton @Component interface AppComponent : WeatherRepositoryComponent, WeatherComponent
126. kotlin-inject-anvil interface WeatherComponent { val weatherRepository: WeatherRepository } @Singleton @Component interface AppComponent : WeatherComponent
127. kotlin-inject-anvil @ContributesTo(AppScope::class) interface WeatherComponent { val weatherRepository: WeatherRepository } @Singleton @Component interface AppComponent
128. kotlin-inject-anvil @ContributesTo(AppScope::class) interface WeatherComponent { val weatherRepository: WeatherRepository } @Singleton @Component @MergeComponent(AppScope::class) interface AppComponent : AppComponentMerged
129. :runtime-optional @Scope annotation class SingleIn( val scope: KClass<*>, ) @Qualifier annotation class ForScope( val scope: KClass<*>, ) abstract class AppScope private constructor()
130. :runtime-optional @Scope annotation class Singleton @Inject @Singleton @ContributesBinding(AppScope::class) class WeatherRepositoryImpl( client: HttpClient, ) : WeatherRepository @ContributesTo(AppScope::class) interface WeatherComponent { val weatherRepository: WeatherRepository } @Component @MergeComponent(AppScope::class) @Singleton interface AppComponent : AppComponentMerged
131. :runtime-optional @Scope annotation class Singleton @Inject @SingleIn(AppScope::class) @ContributesBinding(AppScope::class) class WeatherRepositoryImpl( client: HttpClient, ) : WeatherRepository @ContributesTo(AppScope::class) interface WeatherComponent { val weatherRepository: WeatherRepository } @Component @MergeComponent(AppScope::class) @SingleIn(AppScope::class) interface AppComponent : AppComponentMerged
132. Extending kotlin-inject-anvil class ComposeCounterRenderer : ComposeRenderer<Model>()
133. Extending kotlin-inject-anvil class ComposeCounterRenderer : ComposeRenderer<Model>() { @ContributesTo(RendererScope::class) interface Component { @Provides @IntoMap fun provideComposeCounterRendererCounterPresenterModel( renderer: () -> ComposeRenderer<Model> ): Pair<KClass<out BaseModel>, () -> Renderer<*>> = Model::class to renderer @Provides @SingleIn(RendererScope::class) fun provideComposeCounterRenderer(): ComposeCounterRenderer = ComposeCounterRenderer() } }
134. Extending kotlin-inject-anvil @ContributesRenderer class ComposeCounterRenderer : ComposeRenderer<Model>()
135. KSP • Supports KMP • Supports multiple rounds https://kotlinlang.org/docs/ksp-overview.html
136. KSP include ':runtime' include ':compiler'
137. :runtime // runtime/build.gradle plugins { id 'org.jetbrains.kotlin.multiplatform' }
138. :runtime // runtime/build.gradle plugins { id 'org.jetbrains.kotlin.multiplatform' } // runtime/src/commonMain/kotlin/…/ContributesRenderer.kt @Target(CLASS) @ContributingAnnotation annotation class ContributesRenderer
139. :runtime // runtime/build.gradle plugins { id 'org.jetbrains.kotlin.multiplatform' } // runtime/src/commonMain/kotlin/…/ContributesRenderer.kt @Target(CLASS) @ContributingAnnotation annotation class ContributesRenderer
140. :compiler // compiler/build.gradle plugins { id 'org.jetbrains.kotlin.jvm' id 'com.google.devtools.ksp' } dependencies { ksp "software.amazon.lastmile.kotlin.inject.anvil:compiler:$kia_version" implementation "software.amazon.lastmile.kotlin.inject.anvil:runtime:$kia_version" implementation "com.google.devtools.ksp:symbol-processing-api:$ksp_version" implementation "com.squareup:kotlinpoet:$kotlin_poet_version" implementation "com.squareup:kotlinpoet-ksp:$kotlin_poet_version" testImplementation "dev.zacsweers.kctfork:core:$kotlin_compile_testing_version" testImplementation "dev.zacsweers.kctfork:ksp:$kotlin_compile_testing_version" }
141. :compiler // compiler/src/main/kotlin/…/ContributesRendererProcessorProvider.kt @AutoService(SymbolProcessorProvider::class) class ContributesRendererProcessorProvider : SymbolProcessorProvider { override fun create(environment: SymbolProcessorEnvironment): SymbolProcessor { return ... } }
142. :compiler // compiler/src/main/kotlin/…/ContributesRendererSymbolProcessor.kt private class ContributesRendererSymbolProcessor( private val environment: SymbolProcessorEnvironment, ) : SymbolProcessor { override fun process(resolver: Resolver): List<KSAnnotated> { return emptyList() } }
143. :compiler // compiler/src/main/kotlin/…/ContributesRendererSymbolProcessor.kt private class ContributesRendererSymbolProcessor( private val environment: SymbolProcessorEnvironment, ) : SymbolProcessor { override fun process(resolver: Resolver): List<KSAnnotated> { resolver .getSymbolsWithAnnotation(ContributesRenderer::class) .filterIsInstance<KSClassDeclaration>() .onEach { checkIsPublic(it) } .forEach { generateComponentInterface(it) } return emptyList() } }
144. :compiler private fun generateComponentInterface(clazz: KSClassDeclaration) { val componentClassName = ClassName(LOOKUP_PACKAGE, clazz.safeClassName) val allModels = ... val fileSpec = FileSpec.builder(componentClassName) .addType( TypeSpec .interfaceBuilder(componentClassName) .addOriginatingKSFile(clazz.requireContainingFile()) .addAnnotation(rendererScope) .addOriginAnnotation(clazz) .apply { ... } .addFunctions(allModels.map { createModelBindingFunction(clazz, it) }.toList()) .build(), ) .build() fileSpec.writeTo(codeGenerator, aggregating = false) }
145. :compiler private fun generateComponentInterface(clazz: KSClassDeclaration) { val componentClassName = ClassName(LOOKUP_PACKAGE, clazz.safeClassName) val allModels = ... val fileSpec = FileSpec.builder(componentClassName) .addType( TypeSpec .interfaceBuilder(componentClassName) .addOriginatingKSFile(clazz.requireContainingFile()) .addAnnotation(rendererScope) .addOriginAnnotation(clazz) .apply { ... } .addFunctions(allModels.map { createModelBindingFunction(clazz, it) }.toList()) .build(), ) .build() fileSpec.writeTo(codeGenerator, aggregating = false) }
146. :compiler private fun generateComponentInterface(clazz: KSClassDeclaration) { val componentClassName = ClassName(LOOKUP_PACKAGE, clazz.safeClassName) val allModels = ... val fileSpec = FileSpec.builder(componentClassName) .addType( TypeSpec .interfaceBuilder(componentClassName) .addOriginatingKSFile(clazz.requireContainingFile()) .addAnnotation(rendererScope) .addOriginAnnotation(clazz) .apply { ... } .addFunctions(allModels.map { createModelBindingFunction(clazz, it) }.toList()) .build(), ) .build() fileSpec.writeTo(codeGenerator, aggregating = false) }
147. :compiler private fun generateComponentInterface(clazz: KSClassDeclaration) { val componentClassName = ClassName(LOOKUP_PACKAGE, clazz.safeClassName) val allModels = ... val fileSpec = FileSpec.builder(componentClassName) .addType( TypeSpec .interfaceBuilder(componentClassName) .addOriginatingKSFile(clazz.requireContainingFile()) .addAnnotation(rendererScope) .addOriginAnnotation(clazz) .apply { ... } .addFunctions(allModels.map { createModelBindingFunction(clazz, it) }.toList()) .build(), ) .build() fileSpec.writeTo(codeGenerator, aggregating = false) }
148. :compiler private fun generateComponentInterface(clazz: KSClassDeclaration) { val componentClassName = ClassName(LOOKUP_PACKAGE, clazz.safeClassName) val allModels = ... val fileSpec = FileSpec.builder(componentClassName) .addType( TypeSpec .interfaceBuilder(componentClassName) .addOriginatingKSFile(clazz.requireContainingFile()) .addAnnotation(rendererScope) .addOriginAnnotation(clazz) .apply { ... } .addFunctions(allModels.map { createModelBindingFunction(clazz, it) }.toList()) .build(), ) .build() fileSpec.writeTo(codeGenerator, aggregating = false) }
149. :compiler @Test fun `a component interface is generated in the lookup package for a contributed renderer`() { compile( """ package software.amazon.test import … class Model : BaseModel @ContributesRenderer class TestRenderer : Renderer<Model> { override fun render(model: Model) = Unit } """, componentInterfaceSource, ) { val generatedComponent = testRenderer.generatedComponent assertThat(generatedComponent.packageName).isEqualTo(LOOKUP_PACKAGE) assertThat(generatedComponent).isAnnotatedWith(SingleInRendererScope::class) assertThat(generatedComponent.origin).isEqualTo(testRenderer) … } } https://github.com/square/anvil/blob/main/compiler-utils/src/testFixtures/java/com/squareup/anvil/compiler/internal/testing/AnvilCompilation.kt
150. :compiler val generatedComponent = componentInterface.generatedComponent internal val JvmCompilationResult.componentInterface: Class<*> get() = classLoader.loadClass("software.amazon.test.ComponentInterface") internal val Class<*>.generatedComponent: Class<*> get() = classLoader.loadClass( "$LOOKUP_PACKAGE." + canonicalName.split(".").joinToString(separator = "") { it.capitalize() }, )
151. :compiler val generatedComponent = componentInterface.generatedComponent internal val JvmCompilationResult.componentInterface: Class<*> get() = classLoader.loadClass("software.amazon.test.ComponentInterface") internal val Class<*>.generatedComponent: Class<*> get() = classLoader.loadClass( "$LOOKUP_PACKAGE." + canonicalName.split(".").joinToString(separator = "") { it.capitalize() }, )
152. :compiler val generatedComponent = componentInterface.generatedComponent internal val JvmCompilationResult.componentInterface: Class<*> get() = classLoader.loadClass("software.amazon.test.ComponentInterface") internal val Class<*>.generatedComponent: Class<*> get() = classLoader.loadClass( "$LOOKUP_PACKAGE." + canonicalName.split(".").joinToString(separator = "") { it.capitalize() }, )
153. Extending kotlin-inject-anvil @ContributesRenderer class ComposeCounterRenderer : ComposeRenderer<Model>()
154. Adoption https://x.com/chrisbanes/status/1833549092770718014
155. Adoption https://github.com/slackhq/circuit/releases/tag/0.24.0
156. Summary • KSP is great ◦ KMP support, multiple rounds, deferred processing, incremental processing, … ◦ Simple introduction to the meta-programming world • kotlin-inject is great and improving • kotlin-inject-anvil removes boilerplate and is extensible • Find creative ways to make tools and libraries work for you
157. Extending kotlin-inject for fun & profit Ralf Wondratschek