Add inspection for parameter name mismatch to target class in unobf versions

Author: Earthcomputer

src/main/kotlin/platform/mixin/handlers/InjectorAnnotationHandler.kt

@@ -201,24 +201,24 @@ abstract class InjectorAnnotationHandler : MixinAnnotationHandler {
             val localVariables = targetMethod.localVariables?.sortedBy { it.index }
             return targetMethod.getGenericParameterTypes(clazz, project).asSequence().withIndex()
                 .map { (index, type) ->
-                    val name = localVariables
+                    val knownName = localVariables
                         ?.getOrNull(index + numLocalsToDrop)
                         ?.name
                         ?.toJavaIdentifier()
-                        ?: "par${index + 1}"
-                    type to name
+                    val name = knownName ?: "par${index + 1}"
+                    sanitizedParameter(type, name, knownName != null)
                 }
-                .map { (type, name) -> sanitizedParameter(type, name) }
                 .toList()
         }
 
         @JvmStatic
-        protected fun sanitizedParameter(type: PsiType, name: String?): Parameter {
+        @JvmOverloads
+        protected fun sanitizedParameter(type: PsiType, name: String?, knownName: Boolean = false): Parameter {
             // Parameters should not use ellipsis because others like CallbackInfo may follow
             return if (type is PsiEllipsisType) {
-                Parameter(name?.toJavaIdentifier(), type.toArrayType())
+                Parameter(name?.toJavaIdentifier(), type.toArrayType(), knownName)
             } else {
-                Parameter(name?.toJavaIdentifier(), type)
+                Parameter(name?.toJavaIdentifier(), type, knownName)
             }
         }
     }

src/main/kotlin/platform/mixin/handlers/ModifyVariableHandler.kt

@@ -27,6 +27,7 @@ import com.demonwav.mcdev.platform.mixin.inspection.injector.MethodSignature
 import com.demonwav.mcdev.platform.mixin.inspection.injector.ParameterGroup
 import com.demonwav.mcdev.platform.mixin.util.LocalInfo
 import com.demonwav.mcdev.platform.mixin.util.toPsiType
+import com.demonwav.mcdev.util.Parameter
 import com.demonwav.mcdev.util.constantStringValue
 import com.demonwav.mcdev.util.findContainingMethod
 import com.demonwav.mcdev.util.findModule
@@ -61,31 +62,28 @@ class ModifyVariableHandler : InjectorAnnotationHandler() {
         val localType = method.parameterList.getParameter(0)?.type
         val info = LocalInfo.fromAnnotation(localType, annotation)
 
-        val possibleTypes = mutableSetOf<String>()
+        val elementFactory = JavaPsiFacade.getElementFactory(annotation.project)
+        val seenParams = mutableSetOf<String>()
+        val result = mutableListOf<MethodSignature>()
         for (insn in targets) {
             val matchedLocals = info.matchLocals(
                 module, targetClass, targetMethod, insn.insn,
                 CollectVisitor.Mode.COMPLETION, matchType = false
             ) ?: continue
             for (local in matchedLocals) {
-                possibleTypes += local.desc!!
+                if (seenParams.add(local.desc + local.name)) {
+                    val localType = Type.getType(local.desc).toPsiType(elementFactory)
+                    result += MethodSignature(
+                        listOf(
+                            ParameterGroup(listOf(sanitizedParameter(localType, local.name, local.isNamed))),
+                            targetParamsGroup,
+                        ),
+                        localType,
+                    )
+                }
             }
         }
 
-        val result = mutableListOf<MethodSignature>()
-
-        val elementFactory = JavaPsiFacade.getElementFactory(annotation.project)
-        for (type in possibleTypes) {
-            val psiType = Type.getType(type).toPsiType(elementFactory)
-            result += MethodSignature(
-                listOf(
-                    ParameterGroup(listOf(sanitizedParameter(psiType, "value"))),
-                    targetParamsGroup,
-                ),
-                psiType,
-            )
-        }
-
         return result
     }
 

src/main/kotlin/platform/mixin/handlers/RedirectInjectorHandler.kt

@@ -255,11 +255,13 @@ class RedirectInjectorHandler : InjectorAnnotationHandler() {
                     .mapTo(parameters) { (index, type) ->
                         val i = if (firstMatch.opcode == Opcodes.INVOKESTATIC) index else index + 1
                         val name = sourceClassAndMethod.method.localVariables?.getOrNull(i)?.name?.toJavaIdentifier()
-                        sanitizedParameter(type, name)
+                        sanitizedParameter(type, name, name != null)
                     }
             } else {
-                Type.getArgumentTypes(firstMatch.desc).mapTo(parameters) {
-                    sanitizedParameter(it.toPsiType(elementFactory), null)
+                Type.getArgumentTypes(firstMatch.desc).withIndex().mapTo(parameters) { (index, type) ->
+                    val i = if (firstMatch.opcode == Opcodes.INVOKESTATIC) index else index + 1
+                    val name = sourceClassAndMethod?.method?.localVariables?.getOrNull(i)?.name?.toJavaIdentifier()
+                    sanitizedParameter(type.toPsiType(elementFactory), name, name != null)
                 }
             }
 

src/main/kotlin/platform/mixin/handlers/mixinextras/MixinExtrasInjectorAnnotationHandler.kt

@@ -319,11 +319,13 @@ abstract class MixinExtrasInjectorAnnotationHandler : InjectorAnnotationHandler(
                     genericParams.withIndex().mapTo(parameters) { (index, type) ->
                         val i = if (insn.opcode == Opcodes.INVOKESTATIC) index else index + 1
                         val name = sourceClassAndMethod.method.localVariables?.getOrNull(i)?.name?.toJavaIdentifier()
-                        sanitizedParameter(type, name)
+                        sanitizedParameter(type, name, name != null)
                     }
                 } else {
-                    Type.getArgumentTypes(insn.desc).mapTo(parameters) {
-                        sanitizedParameter(it.toPsiType(elementFactory), null)
+                    Type.getArgumentTypes(insn.desc).withIndex().mapTo(parameters) { (index, type) ->
+                        val i = if (insn.opcode == Opcodes.INVOKESTATIC) index else index + 1
+                        val name = sourceClassAndMethod?.method?.localVariables?.getOrNull(i)?.name?.toJavaIdentifier()
+                        sanitizedParameter(type.toPsiType(elementFactory), name, name != null)
                     }
                 }
                 parameters

src/main/kotlin/platform/mixin/inspection/injector/InvalidInjectorMethodSignatureInspection.kt

@@ -262,8 +262,10 @@ class InvalidInjectorMethodSignatureInspection : MixinInspection() {
             }
             return isAssignable(methodReturnType, expectedReturnType)
         }
+    }
 
-        private fun checkParameters(
+    companion object {
+        fun checkParameters(
             parameterList: PsiParameterList,
             expected: List<ParameterGroup>,
             allowCoerce: Boolean,
@@ -310,7 +312,7 @@ class InvalidInjectorMethodSignatureInspection : MixinInspection() {
         }
     }
 
-    private enum class CheckResult {
+    enum class CheckResult {
         OK, WARNING, ERROR
     }