Merge pull request #35 from evant/issue/types

Again, more robust type name resolution

Author: evant

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

@@ -3,8 +3,8 @@ package me.tatarka.inject.test
 import assertk.assertAll
 import assertk.assertThat
 import assertk.assertions.isEqualTo
-import me.tatarka.inject.annotations.Inject
 import me.tatarka.inject.annotations.Component
+import me.tatarka.inject.annotations.Inject
 import me.tatarka.inject.annotations.Provides
 import kotlin.test.Test
 
@@ -29,6 +29,19 @@ typealias NamedFoo2 = NamedFoo
     @Provides fun foo2(): NamedFoo2 = NamedFoo("2")
 }
 
+@Target(AnnotationTarget.TYPE)
+annotation class FooAnnotation
+
+class GenericFoo<T>(val value: T)
+
+typealias AnnotatedAliasedFoo<T> = @FooAnnotation GenericFoo<T>
+
+@Component abstract class AliasedProvidesComponent {
+    abstract val foo: AnnotatedAliasedFoo<String>
+
+    @Provides fun foo(): AnnotatedAliasedFoo<String> = GenericFoo("1")
+}
+
 class QualifierTest {
 
     @Test

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

@@ -141,6 +141,8 @@ abstract class AstType : AstElement() {
 
     abstract fun isUnit(): Boolean
 
+    abstract fun isFunction(): Boolean
+
     @Suppress("NOTHING_TO_INLINE")
     inline fun isNotUnit() = !isUnit()
 

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

@@ -420,7 +420,7 @@ class InjectGenerator(provider: AstProvider, private val options: Options) :
         if (typeCreator != null) {
             return typeCreator.toResult(skipScoped)
         }
-        if (key.type.name.matches(Regex("kotlin\\.Function[0-9]+.*"))) {
+        if (key.type.isFunction()) {
             val typeAliasName = key.type.typeAliasName
             if (typeAliasName != null) {
                 // Check to see if we have a function matching the type alias

kotlin-inject-compiler-kapt/src/main/kotlin/me/tatarka/inject/compiler/kapt/ModelAst.kt

@@ -55,12 +55,17 @@ interface ModelAstProvider :
         val type = elements.getTypeElement(klass.java.canonicalName)
         return ModelAstType(
             this,
-            declaredType(type, astTypes.asList()),
-            klass.toKmType()
+            elementDeclaredType(type, astTypes.asList()),
+            kmDeclaredType(klass.qualifiedName ?: klass.java.canonicalName, astTypes.asList())
         )
     }
+    private fun kmDeclaredType(name: String, astTypes: List<AstType>): KmType = KmType(0).apply {
+        classifier = KmClassifier.Class(name).apply {
+            arguments.addAll(astTypes.map { KmTypeProjection(KmVariance.INVARIANT, kmDeclaredType(it.name, it.arguments)) })
+        }
+    }
 
-    private fun declaredType(type: TypeElement, astTypes: List<AstType>) = types.getDeclaredType(type, *astTypes.map {
+    private fun elementDeclaredType(type: TypeElement, astTypes: List<AstType>) = types.getDeclaredType(type, *astTypes.map {
         (it as ModelAstType).type
     }.toTypedArray())
 
@@ -452,6 +457,10 @@ private class ModelAstType(
 
     override fun isUnit(): Boolean = type is NoType
 
+    override fun isFunction(): Boolean {
+        return element.toString().matches(Regex("kotlin\\.jvm\\.functions\\.Function[0-9]+.*"))
+    }
+
     override fun asElement(): AstBasicElement =
         ModelBasicElement(this, element)
 
@@ -534,8 +543,13 @@ private val KmAnnotation.type: KmType
         classifier = KmClassifier.Class(className)
     }
 
-private fun KClass<*>.toKmType(): KmType = KmType(0).apply {
-    classifier = KmClassifier.Class(java.canonicalName)
+private fun KClass<*>.toKmType(args: List<KmTypeProjection>): KmType =
+    (qualifiedName ?: java.canonicalName).toKmType(args)
+
+private fun String.toKmType(args: List<KmTypeProjection>): KmType = KmType(0).apply {
+    classifier = KmClassifier.Class(this@toKmType).apply {
+        arguments.addAll(args)
+    }
 }
 
 private fun collectModifiers(flags: Flags?): Set<AstModifier> {

kotlin-inject-compiler-kapt/src/main/kotlin/me/tatarka/inject/compiler/kapt/Util.kt

@@ -21,34 +21,6 @@ fun Element.typeAnnotatedWith(className: String) =
         it.annotationType.asElement().hasAnnotation(className)
     }?.annotationType?.asElement() as? TypeElement
 
-fun TypeName.javaToKotlinType(): TypeName = if (this is ParameterizedTypeName) {
-    (rawType.javaToKotlinType() as ClassName).parameterizedBy(
-        *typeArguments.map { it.javaToKotlinType() }.toTypedArray()
-    )
-} else if (this is WildcardTypeName) {
-    if (inTypes.isNotEmpty()) {
-        WildcardTypeName.consumerOf(inTypes.first().javaToKotlinType())
-    } else {
-        WildcardTypeName.producerOf(outTypes.first().javaToKotlinType())
-    }
-} else {
-    val s = toString()
-    when (s) {
-        "java.util.Map" -> ClassName.bestGuess("kotlin.collections.Map")
-        "java.util.Set" -> ClassName.bestGuess("kotlin.collections.Set")
-        "java.lang.String" -> ClassName.bestGuess("kotlin.String")
-        else -> {
-            val regex = Regex("kotlin\\.jvm\\.functions\\.(Function[0-9]+)")
-            val result = regex.matchEntire(s)
-            if (result != null) {
-                ClassName.bestGuess("kotlin.${result.groupValues[1]}")
-            } else {
-                this
-            }
-        }
-    }
-}
-
 val TypeElement.metadata: KotlinClassMetadata?
     get() {
         val meta = getAnnotation(Metadata::class.java) ?: return null
@@ -168,101 +140,41 @@ private fun ExecutableElement.nameMatches(signature: JvmMemberSignature?): Boole
     return simpleName.contentEquals(signature.name)
 }
 
-fun DeclaredType.rawTypeName(kmType: KmType?): ClassName {
-    val className =
-        (kmType?.classifier as? KmClassifier.Class)?.asClassName()
-            ?: (this.asElement() as TypeElement).asClassName()
-    return className.kotlinClassName()
+fun KmClassifier.asClassName() = when (this) {
+    is KmClassifier.Class -> name.asClassName()
+    is KmClassifier.TypeAlias -> name.asClassName()
+    is KmClassifier.TypeParameter -> null
 }
 
-fun KmClassifier.Class.asClassName() = ClassName.bestGuess(name.replace('/', '.'))
-
-fun ClassName.kotlinClassName(): ClassName {
-    return when (canonicalName) {
-        "java.util.Map" -> ClassName("kotlin.collections", "Map")
-        "java.util.Set" -> ClassName("kotlin.collections", "Set")
-        "java.lang.String" -> ClassName("kotlin", "String")
-        else -> this
+fun kotlinx.metadata.ClassName.asClassName(): ClassName {
+    val split = lastIndexOf('/')
+    return if (split == -1) {
+        ClassName("", this)
+    } else {
+        ClassName(substring(0, split).replace('/', '.'), substring(split + 1))
     }
 }
 
 fun TypeMirror.asTypeName(kmType: KmType?): TypeName {
-    return accept(object : SimpleTypeVisitor7<TypeName, Void?>() {
-        override fun visitPrimitive(t: PrimitiveType, p: Void?): TypeName {
-            return when (t.kind) {
-                TypeKind.BOOLEAN -> BOOLEAN
-                TypeKind.BYTE -> BYTE
-                TypeKind.SHORT -> SHORT
-                TypeKind.INT -> INT
-                TypeKind.LONG -> LONG
-                TypeKind.CHAR -> CHAR
-                TypeKind.FLOAT -> FLOAT
-                TypeKind.DOUBLE -> DOUBLE
-                else -> throw AssertionError()
-            }
-        }
-
-        override fun visitDeclared(t: DeclaredType, p: Void?): TypeName {
-            val isNullable = kmType?.let { Flag.Type.IS_NULLABLE(it.flags) } == true
-            val rawType: ClassName = t.rawTypeName(kmType).copy(nullable = isNullable) as ClassName
-            val enclosingType = t.enclosingType
-            val enclosing = if (enclosingType.kind != TypeKind.NONE &&
-                Modifier.STATIC !in t.asElement().modifiers
-            )
-                enclosingType.accept(this, null) else
-                null
-            if (t.typeArguments.isEmpty() && enclosing !is ParameterizedTypeName) {
-                return rawType
-            }
-
-            val typeArgumentNames = mutableListOf<TypeName>()
-            for (i in 0 until t.typeArguments.size) {
-                val typeArg = t.typeArguments[i]
-                val kmArg = kmType?.arguments?.getOrNull(i)?.type
-                typeArgumentNames += typeArg.asTypeName(kmArg)
-            }
-
-            return if (enclosing is ParameterizedTypeName)
-                enclosing.nestedClass(rawType.simpleName, typeArgumentNames) else
-                rawType.parameterizedBy(typeArgumentNames)
+    if (kmType != null) {
+        val typeName = kmType.asTypeName()
+        if (typeName != null) {
+            return typeName
         }
-
-        override fun visitError(t: ErrorType, p: Void?): TypeName {
-            return visitDeclared(t, p)
-        }
-
-        override fun visitArray(t: ArrayType, p: Void?): TypeName {
-            return when (t.componentType.kind) {
-                TypeKind.BOOLEAN -> BOOLEAN_ARRAY
-                TypeKind.BYTE -> BYTE_ARRAY
-                TypeKind.SHORT -> SHORT_ARRAY
-                TypeKind.INT -> INT_ARRAY
-                TypeKind.LONG -> LONG_ARRAY
-                TypeKind.CHAR -> CHAR_ARRAY
-                TypeKind.FLOAT -> FLOAT_ARRAY
-                TypeKind.DOUBLE -> DOUBLE_ARRAY
-                else -> ARRAY.parameterizedBy(t.componentType.asTypeName(kmType?.arguments?.getOrNull(0)?.type))
-            }
-        }
-
-        override fun visitTypeVariable(
-            t: TypeVariable,
-            p: Void?
-        ): TypeName {
-            return t.asTypeVariableName()
-        }
-
-        override fun visitWildcard(t: WildcardType, p: Void?): TypeName {
-            return t.asWildcardTypeName()
-        }
-
-        override fun visitNoType(t: NoType, p: Void?): TypeName {
-            if (t.kind == TypeKind.VOID) return UNIT
-            return super.visitUnknown(t, p)
-        }
-
-        override fun defaultAction(e: TypeMirror?, p: Void?): TypeName {
-            throw IllegalArgumentException("Unexpected type mirror: " + e!!)
-        }
-    }, null)
+    }
+    return asTypeName()
 }
+
+fun KmType.asTypeName(): TypeName? {
+    val abbreviatedType = abbreviatedType
+    if (abbreviatedType != null) {
+        return abbreviatedType.asTypeName()
+    }
+    val isNullable =  Flag.Type.IS_NULLABLE(flags)
+    val className = classifier.asClassName() ?: return null
+    return if (arguments.isEmpty()) {
+        className
+    } else {
+        className.parameterizedBy(arguments.map { it.type!!.asTypeName()!! })
+    }.copy(nullable = isNullable)
+}

kotlin-inject-compiler-ksp/src/main/kotlin/me/tatarka/inject/compiler/ksp/KSAst.kt

@@ -337,6 +337,10 @@ private class KSAstType(provider: KSAstProvider) : AstType(), KSAstAnnotated, KS
         return type == resolver.builtIns.unitType
     }
 
+    override fun isFunction(): Boolean {
+        return type.declaration.qualifiedName!!.asString().matches(Regex("kotlin\\.Function[0-9]+.*"))
+    }
+
     override fun asElement(): AstBasicElement {
         return KSAstBasicElement(this, declaration)
     }