Use KSP2

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

@@ -496,7 +496,11 @@ private class KSAstType private constructor(
     override fun resolvedType(): AstType {
         val declaration = type.declaration
         return if (declaration is KSTypeAlias) {
-            KSAstType(resolver, declaration.type.resolve().replace(type.arguments))
+            if (type.arguments.isEmpty()) {
+                KSAstType(resolver, declaration.type.resolve())
+            } else {
+                KSAstType(resolver, declaration.type.resolve().replace(type.arguments))
+            }
         } else {
             this
         }

build-logic/src/main/kotlin/kotlin-inject.multiplatform.gradle.kts

@@ -1,8 +1,8 @@
 import org.gradle.accessors.dm.LibrariesForLibs
 import org.gradle.kotlin.dsl.assign
+import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
 import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTargetWithTests
-import org.jetbrains.kotlin.gradle.targets.js.dsl.ExperimentalWasmDsl
 import org.jetbrains.kotlin.gradle.targets.js.npm.tasks.KotlinNpmInstallTask
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompilationTask
 import org.jetbrains.kotlin.gradle.tasks.KotlinJvmCompile

gradle.properties

@@ -2,4 +2,4 @@ org.gradle.parallel=true
 kotlin.mpp.stability.nowarn=true
 kotlin.native.ignoreDisabledTargets=true
 org.gradle.jvmargs=-Xmx4G
-ksp.useKSP2=false
+ksp.useKSP2=true

gradle/libs.versions.toml

@@ -1,7 +1,7 @@
 [versions]
 kotlin-inject = "0.7.3-SNAPSHOT"
-kotlin = "2.0.10"
-ksp = "2.0.10-1.0.24"
+kotlin = "2.1.0"
+ksp = "2.1.0-1.0.29"
 kotlinpoet = "2.0.0"
 junit5 = "5.9.3"
 jvmTarget = "11"
@@ -13,10 +13,11 @@ detekt-formatting = { module = "io.gitlab.arturbosch.detekt:detekt-formatting",
 ksp = { module = "com.google.devtools.ksp:symbol-processing-api", version.ref = "ksp" }
 kotlin-reflect = { module = "org.jetbrains.kotlin:kotlin-reflect", version.ref = "kotlin" }
 kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin" }
-kotlin-compile-testing = { module = "dev.zacsweers.kctfork:ksp", version = "0.4.1" }
+kotlin-compile-testing = { module = "dev.zacsweers.kctfork:ksp", version = "0.7.0" }
 kotlin-metadata-jvm = { module = "org.jetbrains.kotlin:kotlin-metadata-jvm", version.ref = "kotlin" }
 kotlinx-coroutines = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version = "1.8.0" }
 kotlinx-atomicfu = { module = "org.jetbrains.kotlinx:atomicfu", version = "0.23.2" }
+kotlinx-wasm-browser = "org.jetbrains.kotlinx:kotlinx-browser:0.3"
 jdk-compiler = { module = "io.earcam.wrapped:jdk.compiler", version = "1.8.132" }
 assertk = { module = "com.willowtreeapps.assertk:assertk", version = "0.28.0" }
 burst-junit4 = { module = "com.squareup.burst:burst-junit4", version = "1.2.0" }

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

@@ -0,0 +1,29 @@
+package me.tatarka.inject.test
+
+import assertk.assertThat
+import assertk.assertions.isNotNull
+import kotlin.test.Test
+
+class TypeAliasTest {
+
+    @Test
+    fun can_generate_for_typealias_on_typealias_function() {
+        val component = TypeAliasesComponent::class.create()
+
+        assertThat(component.typeAliasFoo()).isNotNull()
+    }
+
+    @Test
+    fun can_generate_for_typealias_on_typealias_to_typealias_function() {
+        val component = TypeAliasesComponent::class.create()
+
+        assertThat(component.typeAliasToTypeAliasFoo()).isNotNull()
+    }
+
+    @Test
+    fun can_generate_for_typealias_on_typealias_to_typealias_to_typealias_function() {
+        val component = TypeAliasesComponent::class.create()
+
+        assertThat(component.typeAliasToTypeAliasToTypeAliasFoo()).isNotNull()
+    }
+}

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

@@ -0,0 +1,28 @@
+package me.tatarka.inject.test
+
+import me.tatarka.inject.annotations.Component
+import me.tatarka.inject.annotations.Inject
+
+@Inject
+class TypeAliasBar
+
+typealias TypeAliasToTypeAliasBar = TypeAliasBar
+typealias TypeAliasToTypeAliasToTypeAliasBar = TypeAliasToTypeAliasBar
+
+@Inject
+fun TypeAliasFoo(
+    bar: TypeAliasBar,
+    typeAliasToBar: TypeAliasToTypeAliasBar,
+    typeAliasToTypeAliasToBar: TypeAliasToTypeAliasToTypeAliasBar,
+) {}
+typealias TypeAliasFoo = () -> Unit
+
+typealias TypeAliasToTypeAliasFoo = TypeAliasFoo
+typealias TypeAliasToTypeAliasToTypeAliasFoo = TypeAliasToTypeAliasFoo
+
+@Component
+abstract class TypeAliasesComponent {
+    abstract fun typeAliasFoo(): TypeAliasFoo
+    abstract fun typeAliasToTypeAliasFoo(): TypeAliasToTypeAliasFoo
+    abstract fun typeAliasToTypeAliasToTypeAliasFoo(): TypeAliasToTypeAliasToTypeAliasFoo
+}

integration-tests/ksp/build.gradle.kts

@@ -50,6 +50,11 @@ kotlin {
                 implementation(libs.kotlin.reflect)
             }
         }
+        wasmJsMain {
+            dependencies {
+                implementation(libs.kotlinx.wasm.browser)
+            }
+        }
     }
 
     targets.all {

integration-tests/ksp1-companion/.gitignore

@@ -0,0 +1 @@
+/build

integration-tests/ksp1-companion/build.gradle.kts

@@ -0,0 +1,48 @@
+import com.google.devtools.ksp.KspExperimental
+
+plugins {
+    id("kotlin-inject.multiplatform")
+    id("kotlin-inject.detekt")
+    id("kotlin-inject.merge-tests")
+    id("com.google.devtools.ksp")
+}
+
+dependencies {
+    addAllKspTargets(kotlin, project(":kotlin-inject-compiler:kotlin-inject-compiler-ksp"))
+}
+
+kotlin {
+    jvm {
+        withJava()
+    }
+
+    sourceSets {
+        commonMain {
+            kotlin.srcDir("../common-companion/src/main/kotlin")
+            kotlin.srcDir("build/generated/ksp/metadata/commonMain/kotlin")
+            dependencies {
+                implementation(project(":kotlin-inject-runtime-kmp"))
+                implementation(project(":integration-tests:module"))
+            }
+        }
+        commonTest {
+            kotlin.srcDir("../common-companion-test/src/test/kotlin")
+            dependencies {
+                implementation(libs.kotlin.test)
+                implementation(libs.assertk)
+            }
+        }
+        nativeMain {
+            kotlin.srcDir("../common-native/src/main/kotlin")
+        }
+        nativeTest {
+            kotlin.srcDir("../common-native/src/test/kotlin")
+        }
+    }
+}
+
+ksp {
+    arg("me.tatarka.inject.generateCompanionExtensions", "true")
+    @OptIn(KspExperimental::class)
+    useKsp2 = false
+}

integration-tests/ksp1/.gitignore

@@ -0,0 +1 @@
+/build

integration-tests/ksp1/build.gradle.kts

@@ -0,0 +1,81 @@
+import com.google.devtools.ksp.KspExperimental
+
+plugins {
+    id("kotlin-inject.multiplatform")
+    id("kotlin-inject.detekt")
+    id("kotlin-inject.merge-tests")
+    id("com.google.devtools.ksp")
+}
+
+dependencies {
+    addAllKspTargets(kotlin, project(":kotlin-inject-compiler:kotlin-inject-compiler-ksp"))
+    kspJvmTest(project(":kotlin-inject-compiler:kotlin-inject-compiler-ksp"))
+}
+
+kotlin {
+    jvm {
+        withJava()
+    }
+
+    sourceSets {
+        commonMain {
+            kotlin.srcDir("../common/src/main/kotlin")
+            kotlin.srcDir("build/generated/ksp/metadata/commonMain/kotlin")
+            dependencies {
+                implementation(project(":kotlin-inject-runtime-kmp"))
+                implementation(project(":integration-tests:module"))
+            }
+        }
+        commonTest {
+            kotlin.srcDir("../common-test/src/test/kotlin")
+            dependencies {
+                implementation(kotlin("test"))
+                implementation(libs.kotlinx.coroutines)
+                implementation(libs.assertk)
+            }
+        }
+        nativeMain {
+            kotlin.srcDir("../common-native/src/main/kotlin")
+        }
+        nativeTest {
+            kotlin.srcDir("../common-native/src/test/kotlin")
+        }
+        jvmMain {
+            kotlin.srcDir("../common-jvm/src/main/kotlin")
+            dependencies {
+                api(libs.javax.inject)
+            }
+        }
+        jvmTest {
+            kotlin.srcDir("../common-jvm/src/test/kotlin")
+            dependencies {
+                implementation(libs.kotlin.reflect)
+            }
+        }
+        wasmJsMain {
+            dependencies {
+                implementation(libs.kotlinx.wasm.browser)
+            }
+        }
+    }
+
+    targets.all {
+        compilations.all {
+            compileTaskProvider.configure {
+                compilerOptions.allWarningsAsErrors = true
+            }
+        }
+    }
+}
+
+java {
+    val test by sourceSets.existing {
+        java.srcDir("../common-jvm/src/test/java")
+    }
+}
+
+ksp {
+    arg("me.tatarka.inject.enableJavaxAnnotations", "true")
+    @OptIn(KspExperimental::class)
+    useKsp2 = false
+}

integration-tests/ksp1/src/commonTest/kotlin/me/tatarka/inject/test/runTest.kt

@@ -0,0 +1,8 @@
+package me.tatarka.inject.test
+
+import kotlinx.coroutines.CoroutineScope
+
+/**
+ * Workaround to use suspending functions in unit tests
+ */
+expect fun runTest(block: suspend (scope: CoroutineScope) -> Unit)

integration-tests/ksp1/src/jsTest/kotlin/me/tatarka/inject/test/runTest.kt

@@ -0,0 +1,14 @@
+package me.tatarka.inject.test
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.DelicateCoroutinesApi
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.promise
+
+/**
+ * Workaround to use suspending functions in unit tests
+ */
+@OptIn(DelicateCoroutinesApi::class)
+actual fun runTest(block: suspend (scope: CoroutineScope) -> Unit) {
+    GlobalScope.promise { block(this) }
+}

integration-tests/ksp1/src/jvmTest/kotlin/me/tatarka/inject/test/runTest.kt

@@ -0,0 +1,9 @@
+package me.tatarka.inject.test
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.runBlocking
+
+/**
+ * Workaround to use suspending functions in unit tests
+ */
+actual fun runTest(block: suspend (scope: CoroutineScope) -> Unit) = runBlocking { block(this) }

integration-tests/ksp1/src/nativeTest/kotlin/me/tatarka/inject/test/runTest.kt

@@ -0,0 +1,9 @@
+package me.tatarka.inject.test
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.runBlocking
+
+/**
+ * Workaround to use suspending functions in unit tests
+ */
+actual fun runTest(block: suspend (scope: CoroutineScope) -> Unit) = runBlocking { block(this) }

integration-tests/ksp1/src/wasmJsTest/kotlin/me/tatarka/inject/test/runTest.kt

@@ -0,0 +1,14 @@
+package me.tatarka.inject.test
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.DelicateCoroutinesApi
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.promise
+
+/**
+ * Workaround to use suspending functions in unit tests
+ */
+@OptIn(DelicateCoroutinesApi::class)
+actual fun runTest(block: suspend (scope: CoroutineScope) -> Unit) {
+    GlobalScope.promise { block(this) }
+}

kotlin-inject-compiler/core/src/main/kotlin/me/tatarka/inject/compiler/TypeResultResolver.kt

@@ -91,11 +91,9 @@ class TypeResultResolver(private val provider: AstProvider, private val options:
         var assistedFailed = false
         val args = context.args.toMutableList()
         for (param in params) {
-            val type = if (param.type.isPlatform()) {
-                param.type.makeNonNullable()
-            } else {
-                param.type
-            }
+            val resolvedType = if (param.type.isTypeAlias()) param.type.resolvedType() else param.type
+            val type = if (resolvedType.isPlatform()) resolvedType.makeNonNullable() else resolvedType
+
             val qualifier = qualifier(provider, options, param, type)
             val key = TypeKey(type, qualifier)
             if (param.isAssisted()) {
@@ -232,7 +230,7 @@ class TypeResultResolver(private val provider: AstProvider, private val options:
             return map(key)
         }
 
-        if (key.type.isFunction()) {
+        if (key.type.isFunctionOrTypeAliasOfFunction()) {
             return functionType(element, key)
         }
 
@@ -244,15 +242,16 @@ class TypeResultResolver(private val provider: AstProvider, private val options:
         }
 
         val astClass = key.type.toAstClass()
+
+        if (astClass.isObject && astClass.isInject()) {
+            return Object(astClass.type)
+        }
+
         val injectCtor = astClass.findInjectConstructors(provider.messenger, options)
         if (injectCtor != null) {
             return constructor(key, injectCtor, astClass)
         }
 
-        if (astClass.isInject() && astClass.isObject) {
-            return Object(astClass.type)
-        }
-
         if (astClass.isAssistedFactory()) {
             return assistedFactory(astClass, key)
         }
@@ -383,8 +382,10 @@ class TypeResultResolver(private val provider: AstProvider, private val options:
         val resolveType = key.type.resolvedType()
         val args = resolveType.arguments.dropLast(1)
         if (key.type.isTypeAlias()) {
+            val resolvedTypeAlias = key.type.resolveToHighestTypeAlias()
+
             // Check to see if we have a function matching the type alias
-            val functions = provider.findFunctions(key.type.packageName, key.type.simpleName)
+            val functions = provider.findFunctions(resolvedTypeAlias.packageName, resolvedTypeAlias.simpleName)
             val injectedFunction = functions.find { it.isInject() }
             if (injectedFunction != null) {
                 return NamedFunction(
@@ -654,4 +655,4 @@ class TypeResultResolver(private val provider: AstProvider, private val options:
         // default values are present.
         val args: List<Pair<AstType, String>>,
     )
-}
+}