Fix implementation methods for other interfaces (except first MvpView)

Author: anton-knyazev

app/src/main/java/com/omegar/mvp/Addon.kt

@@ -0,0 +1,11 @@
+package com.omegar.mvp
+
+interface Addon<N> {
+
+    var addon: N?
+        get() = null
+        set(value) {
+            TODO()
+        }
+
+}

app/src/main/java/com/omegar/mvp/MoxyActivity.kt

@@ -6,7 +6,7 @@ import com.omegar.mvp.ktx.providePresenter
 import kotlin.time.Duration
 import kotlin.time.Duration.Companion.seconds
 
-class MoxyActivity: MvpAppCompatActivity(R.layout.activity_moxy), MoxyView<Int> {
+class MoxyActivity: MvpAppCompatActivity(R.layout.activity_moxy), MoxyView {
 
     companion object {
         var first: Boolean = true

app/src/main/java/com/omegar/mvp/MoxyFragment.kt

@@ -6,7 +6,7 @@ import com.omegar.mvp.ktx.providePresenter
 import kotlin.time.Duration
 import kotlin.time.Duration.Companion.seconds
 
-class MoxyFragment : MvpAppCompatFragment(R.layout.activity_moxy), MoxyView<Int> {
+class MoxyFragment : MvpAppCompatFragment(R.layout.activity_moxy), MoxyView {
 
     private val presenter: MoxyPresenter by providePresenter {
         MoxyPresenter()

app/src/main/java/com/omegar/mvp/MoxyPresenter.kt

@@ -4,7 +4,7 @@ import kotlin.time.Duration
 
 
 @InjectViewState
-class MoxyPresenter : BasePresenter<Long, MoxyView<Int>>() {
+class MoxyPresenter : BasePresenter<Long, MoxyView>() {
 
     init {
         viewState.showToast("Hello World!")

app/src/main/java/com/omegar/mvp/MoxyView.kt

@@ -4,13 +4,13 @@ import com.omegar.mvp.viewstate.strategy.MoxyViewCommand
 import com.omegar.mvp.viewstate.strategy.StrategyType.ONE_EXECUTION
 import kotlin.time.Duration
 
-interface MoxyView<T>: BaseView {
+interface MoxyView: Addon<Long>, BaseView {
 
 
     var duration: Duration
 
     @MoxyViewCommand(ONE_EXECUTION)
-    fun test(count: T)
+    fun test(count: Int)
 
     @MoxyViewCommand(ONE_EXECUTION)
     fun showToast(message: String)

moxy/compiler/src/main/java/com/omegar/mvp/compiler/ksp/KspViewParser.kt

@@ -16,6 +16,7 @@ import com.omegar.mvp.compiler.entities.View
 import com.omegar.mvp.compiler.processors.OriginatingMarker
 import com.omegar.mvp.compiler.processors.ViewParser
 import com.omegar.mvp.viewstate.strategy.MoxyViewCommand
+import com.squareup.kotlinpoet.TypeName
 import com.squareup.kotlinpoet.ksp.TypeParameterResolver
 import com.squareup.kotlinpoet.ksp.toClassName
 import com.squareup.kotlinpoet.ksp.toTypeName
@@ -53,27 +54,18 @@ class KspViewParser(
         presenterCache[presenterKey]?.let {
             return it
         }
-
-        val (superPresenter, view) =
-            presenterDeclaration
-                .superTypes
-                .firstNotNullOf { reference ->
-                    (reference.resolve().declaration as? KSClassDeclaration)
-                        ?.takeIf { it.classKind == ClassKind.CLASS }
-                        ?.let {
-                            it to reference.getView()!!
-                        }
-                }
+        val (superPresenter, view) = presenterDeclaration.getSuperPresenterAndView()
 
         val viewClassName = view.toClassName()
         val viewKey = viewClassName.simpleName
 
         val viewDeclaration = view.declaration as KSClassDeclaration
 
+        val superView = this(superPresenter)
         viewCache[viewKey]?.let {
             val newView = it.copy(
                 presenterClassName = presenterDeclaration.toClassName(),
-                parent = this(superPresenter)
+                parent = superView
             )
                 .putTags(presenterDeclaration, viewDeclaration)
             presenterCache[presenterKey] = newView
@@ -96,13 +88,13 @@ class KspViewParser(
             View(
                 className = viewClassName,
                 presenterClassName = presenterDeclaration.toClassName(),
-                methods = viewDeclaration.getMethods(),
+                methods = viewDeclaration.getMethods(superView),
                 viewTypeParams = viewDeclaration.typeParameters
                     .filterNot { mvpView.isAssignableFrom(it.bounds.first().resolve()) }
                     .map { it.toTypeVariableName() },
                 presenterInnerTypeParams = view.innerArguments.map { it.toTypeName(presenterDeclaration.typeParameters.toTypeParameterResolver()) },
                 reflectorPackage = reflectorPackage,
-                parent = this(superPresenter)
+                parent = superView
             ).putTags(presenterDeclaration, viewDeclaration)
         }
 
@@ -112,7 +104,18 @@ class KspViewParser(
         return newView
     }
 
-    private fun KSTypeReference.getView(): KSType? {
+    private fun KSClassDeclaration.getSuperPresenterAndView(): Pair<KSClassDeclaration, KSType> {
+        return superTypes
+            .firstNotNullOf { reference ->
+                (reference.resolve().declaration as? KSClassDeclaration)
+                    ?.takeIf { it.classKind == ClassKind.CLASS }
+                    ?.let {
+                        it to reference.findView()!!
+                    }
+            }
+    }
+
+    private fun KSTypeReference.findView(): KSType? {
         val type = element
             ?.typeArguments
             ?.asSequence()
@@ -139,24 +142,40 @@ class KspViewParser(
         }
     }
 
-    private fun KSClassDeclaration.getMethods(): List<View.Method> {
-        val parameterResolver = typeParameters.toTypeParameterResolver()
-        return declarations.mapNotNull { declaration ->
+    private fun KSClassDeclaration.getMethods(superView: View?): List<View.Method> {
+        val parameterResolver: TypeParameterResolver = typeParameters.toTypeParameterResolver()
+        val typeNameResolverMap = mutableMapOf<KSDeclaration?, TypeNameResolver>()
+        val additionalSequence = superTypes
+            .map { it.resolve() }
+            .filter { it.toClassName() != superView?.className }
+            .map {
+                typeNameResolverMap[it.declaration] = TypeNameResolver(it, parameterResolver)
+                it.declaration
+            }
+            .filterIsInstance<KSClassDeclaration>()
+            .flatMap {
+                it.declarations
+            }
+        val typeNameResolver = TypeNameResolver(emptyList(), this, parameterResolver)
+        return (declarations + additionalSequence)
+            .mapNotNull { declaration ->
                 when (declaration) {
                     is KSFunctionDeclaration -> {
                         if (declaration.simpleName.getShortName() in ANY_FUNCTION_SIMPLE_NAME) null else {
-                            declaration.toMethod(parameterResolver)
+                            declaration.toMethod(typeNameResolverMap[declaration.parentDeclaration] ?: typeNameResolver)
                         }
                     }
+
                     is KSPropertyDeclaration -> {
-                        declaration.toMethod(parameterResolver)
+                        declaration.toMethod(typeNameResolverMap[declaration.parentDeclaration] ?: typeNameResolver)
                     }
+
                     else -> null
                 }
             }.toList()
-     }
+    }
 
-    private fun KSFunctionDeclaration.toMethod(resolver: TypeParameterResolver): View.Method {
+    private fun KSFunctionDeclaration.toMethod(resolver: TypeNameResolver): View.Method {
         val params = parameters.map {
             View.Method.Param(
                 name = it.name?.getShortName() ?: PROPERTY_PARAM_NAME,
@@ -171,7 +190,7 @@ class KspViewParser(
         ).putTags(this)
     }
 
-    private fun KSPropertyDeclaration.toMethod(resolver: TypeParameterResolver): View.Method {
+    private fun KSPropertyDeclaration.toMethod(resolver: TypeNameResolver): View.Method {
         return View.Method(
             name = simpleName.getShortName(),
             type = View.Method.Type.Property(
@@ -213,4 +232,39 @@ class KspViewParser(
         putTag(KspOriginatingMarker.Files::class, KspOriginatingMarker.Files(declarations.mapNotNull { it.containingFile }))
     }
 
+    private fun KSTypeReference.toTypeName(resolver: TypeNameResolver): TypeName {
+        val ksType = this.resolve()
+        return when (val declaration = ksType.declaration) {
+            is KSTypeParameter -> resolver[declaration.name.getShortName()].copy(nullable = ksType.isMarkedNullable)
+            else -> toTypeName(resolver.parentTypeParameterResolver)
+        }
+    }
+
+    private class TypeNameResolver(
+        innerArguments: List<KSTypeArgument>,
+        declaration: KSDeclaration,
+        val parentTypeParameterResolver: TypeParameterResolver
+    ) {
+        private val innerParametersMap = mutableMapOf<String, TypeName>()
+
+        constructor(
+            type: KSType,
+            parentTypeParameterResolver: TypeParameterResolver
+        ) : this(type.innerArguments, type.declaration, parentTypeParameterResolver)
+
+        init {
+            val innerTypeNames = innerArguments.map { it.toTypeName(parentTypeParameterResolver) }
+            declaration.typeParameters.mapIndexed { index, ksTypeParameter ->
+                val typeName = innerTypeNames.getOrNull(index) ?: return@mapIndexed
+                innerParametersMap[ksTypeParameter.name.getShortName()] = typeName
+            }
+
+        }
+
+        operator fun get(index: String): TypeName {
+            return innerParametersMap[index] ?: parentTypeParameterResolver[index]
+        }
+
+    }
+
 }