Generate graph when @Inject is typealiased (#234)

Follow typealias for annotations

Author: jstarczewski

ast/ksp/src/main/kotlin/me/tatarka/kotlin/ast/KSUtil.kt

@@ -4,6 +4,7 @@ import com.google.devtools.ksp.symbol.KSAnnotated
 import com.google.devtools.ksp.symbol.KSAnnotation
 import com.google.devtools.ksp.symbol.KSDeclaration
 import com.google.devtools.ksp.symbol.KSType
+import com.google.devtools.ksp.symbol.KSTypeAlias
 import com.google.devtools.ksp.symbol.KSTypeParameter
 import com.google.devtools.ksp.symbol.KSTypeReference
 import me.tatarka.kotlin.ast.internal.HashCollector
@@ -25,12 +26,14 @@ internal fun KSAnnotated.hasAnnotation(packageName: String, simpleName: String):
     return annotations.any { it.hasName(packageName, simpleName) }
 }
 
-private fun KSAnnotation.hasName(packageName: String, simpleName: String): Boolean {
-    // we can skip resolving if the short name doesn't match
-    if (shortName.asString() != simpleName) return false
-    val declaration = annotationType.resolve().declaration
-    return declaration.packageName.asString() == packageName
-}
+private fun KSAnnotation.hasName(packageName: String, simpleName: String): Boolean =
+    annotationType.resolve().declaration.hasName(packageName, simpleName)
+
+private tailrec fun KSDeclaration.hasName(packageName: String, simpleName: String): Boolean =
+    when (this) {
+        is KSTypeAlias -> type.resolve().declaration.hasName(packageName, simpleName)
+        else -> this.simpleName.asString() == simpleName && this.packageName.asString() == packageName
+    }
 
 /**
  * package name except root is "" instead of "<root>"

integration-tests/common/src/test/kotlin/me/tatarka/inject/test/TypeAliasInjectTest.kt

@@ -0,0 +1,84 @@
+package me.tatarka.inject.test
+
+import assertk.assertThat
+import assertk.assertions.isNotNull
+import me.tatarka.inject.annotations.Component
+import me.tatarka.inject.annotations.Inject
+import kotlin.test.Test
+
+typealias InjectTypeAlias = Inject
+
+class FooWithPrimaryConstructorInjectTypeAlias @InjectTypeAlias constructor()
+
+class FooWithSecondaryConstructorInjectTypeAlias(private val prop: String) {
+
+    @InjectTypeAlias
+    constructor() : this("prop")
+}
+
+@InjectTypeAlias
+class FooWithInjectTypeAlias
+
+typealias fooWithPrimaryCreator = () -> FooWithPrimaryConstructorInjectTypeAlias
+
+@InjectTypeAlias
+fun fooWithPrimaryCreator(foo: FooWithPrimaryConstructorInjectTypeAlias) = foo
+
+typealias TypeAliasToInjectTypeAlias = InjectTypeAlias
+
+typealias TypeAliasToTypeAliasToInjectTypeAlias = TypeAliasToInjectTypeAlias
+
+@TypeAliasToTypeAliasToInjectTypeAlias
+class FooWithTypeAliasToTypeAliasToTypeAlias
+
+@Component
+abstract class InjectTypeAliasComponent {
+
+    abstract val primaryConstructorWithInjectTypeAlias: FooWithPrimaryConstructorInjectTypeAlias
+
+    abstract val secondaryConstructorWithInjectTypeAlias: FooWithSecondaryConstructorInjectTypeAlias
+
+    abstract val classWithInjectTypeAlias: FooWithInjectTypeAlias
+
+    abstract val functionWithInjectTypeAlias: fooWithPrimaryCreator
+
+    abstract val fooWithTypeAliasToTypeAliasToTypeAlias: FooWithTypeAliasToTypeAliasToTypeAlias
+}
+
+class TypeAliasInjectTest {
+
+    @Test
+    fun can_generate_for_inject_typealias_on_primary_constructor() {
+        val component = InjectTypeAliasComponent::class.create()
+
+        assertThat(component.primaryConstructorWithInjectTypeAlias).isNotNull()
+    }
+
+    @Test
+    fun can_generate_for_inject_typealias_on_secondary_constructor() {
+        val component = InjectTypeAliasComponent::class.create()
+
+        assertThat(component.secondaryConstructorWithInjectTypeAlias).isNotNull()
+    }
+
+    @Test
+    fun can_generate_for_inject_typealias_on_class() {
+        val component = InjectTypeAliasComponent::class.create()
+
+        assertThat(component.classWithInjectTypeAlias).isNotNull()
+    }
+
+    @Test
+    fun can_generate_for_inject_typealias_on_function() {
+        val component = InjectTypeAliasComponent::class.create()
+
+        assertThat(component.functionWithInjectTypeAlias).isNotNull()
+    }
+
+    @Test
+    fun can_generate_for_type_alias_to_type_alias_to_inject_type_alias_on_class() {
+        val component = InjectTypeAliasComponent::class.create()
+
+        assertThat(component.fooWithTypeAliasToTypeAliasToTypeAlias).isNotNull()
+    }
+}