Fix capture of MixinAnnotationHandler in cached value

Earthcomputer · Earthcomputer · commit 81686d462819 · 2025-02-25T13:44:43.000Z
diff --git a/src/main/kotlin/platform/mixin/expression/MEExpressionCompletionUtil.kt b/src/main/kotlin/platform/mixin/expression/MEExpressionCompletionUtil.kt
@@ -246,12 +246,11 @@ object MEExpressionCompletionUtil {
 
         val modifierList = expressionAnnotation.findContainingModifierList() ?: return emptyList()
 
-        val (handler, handlerAnnotation) = modifierList.annotations.mapFirstNotNull { annotation ->
-            val handler = MixinAnnotationHandler.forMixinAnnotation(annotation, project) ?: return@mapFirstNotNull null
-            handler to annotation
+        val handlerAnnotation = modifierList.annotations.firstOrNull {
+            MixinAnnotationHandler.forMixinAnnotation(it, project) != null
         } ?: return emptyList()
 
-        return handler.resolveTarget(handlerAnnotation).flatMap { member ->
+        return MixinAnnotationHandler.resolveTarget(handlerAnnotation).flatMap { member ->
             (member as? MethodTargetMember)?.classAndMethod
                 ?.let { (clazz, method) -> MEExpressionMatchUtil.getFlowMap(project, clazz, method) }
                 ?.values
diff --git a/src/main/kotlin/platform/mixin/handlers/AccessorHandler.kt b/src/main/kotlin/platform/mixin/handlers/AccessorHandler.kt
@@ -98,7 +98,8 @@ class AccessorHandler : MixinMemberAnnotationHandler {
 
     fun findAccessorTargetForReference(method: PsiMethod): SmartPsiElementPointer<PsiField>? {
         val accessor = method.findAnnotation(ACCESSOR) ?: return null
-        val targetMember = resolveTarget(accessor).firstOrNull() as? FieldTargetMember ?: return null
+        val targetMember = MixinAnnotationHandler.resolveTarget(accessor).firstOrNull() as? FieldTargetMember
+            ?: return null
         return targetMember.classAndField.field.findOrConstructSourceField(
             targetMember.classAndField.clazz,
             method.project,
diff --git a/src/main/kotlin/platform/mixin/handlers/InvokerHandler.kt b/src/main/kotlin/platform/mixin/handlers/InvokerHandler.kt
@@ -99,7 +99,8 @@ class InvokerHandler : MixinMemberAnnotationHandler {
 
     fun findInvokerTargetForReference(member: PsiMember): SmartPsiElementPointer<PsiMethod>? {
         val accessor = member.findAnnotation(INVOKER) ?: return null
-        val invokerTarget = resolveTarget(accessor).firstOrNull() as? MethodTargetMember ?: return null
+        val invokerTarget = MixinAnnotationHandler.resolveTarget(accessor).firstOrNull() as? MethodTargetMember
+            ?: return null
         return invokerTarget.classAndMethod.method.findOrConstructSourceMethod(
             invokerTarget.classAndMethod.clazz,
             member.project,
diff --git a/src/main/kotlin/platform/mixin/handlers/MixinAnnotationHandler.kt b/src/main/kotlin/platform/mixin/handlers/MixinAnnotationHandler.kt
@@ -48,10 +48,6 @@ import javax.swing.Icon
 import org.objectweb.asm.tree.ClassNode
 
 interface MixinAnnotationHandler {
-    fun resolveTarget(annotation: PsiAnnotation) = annotation.cached(PsiModificationTracker.MODIFICATION_COUNT) {
-        val containingClass = annotation.findContainingClass() ?: return@cached emptyList()
-        containingClass.mixinTargets.flatMap { resolveTarget(annotation, it) }
-    }
 
     fun resolveTarget(annotation: PsiAnnotation, targetClass: ClassNode): List<MixinTargetMember>
 
@@ -131,6 +127,14 @@ interface MixinAnnotationHandler {
 
             return null
         }
+
+        fun resolveTarget(annotation: PsiAnnotation): List<MixinTargetMember> {
+            return annotation.cached(PsiModificationTracker.MODIFICATION_COUNT) {
+                val handler = forMixinAnnotation(annotation) ?: return@cached emptyList()
+                val containingClass = annotation.findContainingClass() ?: return@cached emptyList()
+                containingClass.mixinTargets.flatMap { handler.resolveTarget(annotation, it) }
+            }
+        }
     }
 }
 
diff --git a/src/main/kotlin/platform/mixin/handlers/OverwriteHandler.kt b/src/main/kotlin/platform/mixin/handlers/OverwriteHandler.kt
@@ -21,7 +21,6 @@
 package com.demonwav.mcdev.platform.mixin.handlers
 
 import com.demonwav.mcdev.platform.mixin.util.MethodTargetMember
-import com.demonwav.mcdev.platform.mixin.util.MixinConstants.Annotations.OVERWRITE
 import com.demonwav.mcdev.platform.mixin.util.MixinTargetMember
 import com.demonwav.mcdev.platform.mixin.util.findMethod
 import com.demonwav.mcdev.util.memberReference
@@ -43,10 +42,4 @@ class OverwriteHandler : MixinMemberAnnotationHandler {
     }
 
     override val isEntryPoint = true
-
-    companion object {
-        fun getInstance(): OverwriteHandler? {
-            return MixinAnnotationHandler.forMixinAnnotation(OVERWRITE) as? OverwriteHandler
-        }
-    }
 }
diff --git a/src/main/kotlin/platform/mixin/handlers/ShadowHandler.kt b/src/main/kotlin/platform/mixin/handlers/ShadowHandler.kt
@@ -80,14 +80,14 @@ class ShadowHandler : MixinMemberAnnotationHandler {
 
     fun findFirstShadowTargetForNavigation(member: PsiMember): SmartPsiElementPointer<PsiElement>? {
         val shadow = member.findAnnotation(SHADOW) ?: return null
-        val shadowTarget = resolveTarget(shadow).firstOrNull() ?: return null
+        val shadowTarget = MixinAnnotationHandler.resolveTarget(shadow).firstOrNull() ?: return null
         return shadowTarget.findSourceElement(member.project, member.resolveScope, canDecompile = false)
             ?.createSmartPointer()
     }
 
     fun findFirstShadowTargetForReference(member: PsiMember): SmartPsiElementPointer<PsiMember>? {
         val shadow = member.findAnnotation(SHADOW) ?: return null
-        val shadowTarget = resolveTarget(shadow).firstOrNull() ?: return null
+        val shadowTarget = MixinAnnotationHandler.resolveTarget(shadow).firstOrNull() ?: return null
         return shadowTarget.findOrConstructSourceMember(member.project, member.resolveScope, canDecompile = false)
             .createSmartPointer()
     }
diff --git a/src/main/kotlin/platform/mixin/handlers/injectionPoint/ConstantInjectionPoint.kt b/src/main/kotlin/platform/mixin/handlers/injectionPoint/ConstantInjectionPoint.kt
@@ -87,12 +87,9 @@ class ConstantInjectionPoint : InjectionPoint<PsiElement>() {
     override fun getArgsValues(at: PsiAnnotation, key: String): Array<Any> {
         fun collectTargets(constantToCompletion: (Any) -> Any?): Array<Any> {
             val injectorAnnotation = AtResolver.findInjectorAnnotation(at) ?: return ArrayUtilRt.EMPTY_OBJECT_ARRAY
-            val handler = MixinAnnotationHandler.forMixinAnnotation(injectorAnnotation)
-                ?: return ArrayUtilRt.EMPTY_OBJECT_ARRAY
-
             val expandConditions = parseExpandConditions(AtResolver.getArgs(at))
 
-            return handler.resolveTarget(injectorAnnotation)
+            return MixinAnnotationHandler.resolveTarget(injectorAnnotation)
                 .asSequence()
                 .filterIsInstance<MethodTargetMember>()
                 .flatMap { target ->
diff --git a/src/main/kotlin/platform/mixin/handlers/injectionPoint/ConstantStringMethodInjectionPoint.kt b/src/main/kotlin/platform/mixin/handlers/injectionPoint/ConstantStringMethodInjectionPoint.kt
@@ -99,10 +99,8 @@ class ConstantStringMethodInjectionPoint : AbstractMethodInjectionPoint() {
         }
 
         val injectorAnnotation = AtResolver.findInjectorAnnotation(at) ?: return ArrayUtilRt.EMPTY_OBJECT_ARRAY
-        val handler = MixinAnnotationHandler.forMixinAnnotation(injectorAnnotation)
-            ?: return ArrayUtilRt.EMPTY_OBJECT_ARRAY
 
-        return handler.resolveTarget(injectorAnnotation).asSequence()
+        return MixinAnnotationHandler.resolveTarget(injectorAnnotation).asSequence()
             .filterIsInstance<MethodTargetMember>()
             .flatMap { target ->
                 val insns = target.classAndMethod.method.instructions ?: return@flatMap emptySequence()
diff --git a/src/main/kotlin/platform/mixin/handlers/injectionPoint/NewInsnInjectionPoint.kt b/src/main/kotlin/platform/mixin/handlers/injectionPoint/NewInsnInjectionPoint.kt
@@ -70,10 +70,8 @@ class NewInsnInjectionPoint : InjectionPoint<PsiMember>() {
         }
 
         val injectorAnnotation = AtResolver.findInjectorAnnotation(at) ?: return ArrayUtilRt.EMPTY_OBJECT_ARRAY
-        val handler = MixinAnnotationHandler.forMixinAnnotation(injectorAnnotation)
-            ?: return ArrayUtilRt.EMPTY_OBJECT_ARRAY
 
-        return handler.resolveTarget(injectorAnnotation).asSequence()
+        return MixinAnnotationHandler.resolveTarget(injectorAnnotation).asSequence()
             .filterIsInstance<MethodTargetMember>()
             .flatMap { target ->
                 target.classAndMethod.method.instructions?.asSequence()?.mapNotNull { insn ->
diff --git a/src/main/kotlin/platform/mixin/inspection/MixinAnnotationTargetInspection.kt b/src/main/kotlin/platform/mixin/inspection/MixinAnnotationTargetInspection.kt
@@ -51,8 +51,7 @@ class MixinAnnotationTargetInspection : MixinInspection() {
                     if (parentAnnotation == null) {
                         return
                     }
-                    val handler = MixinAnnotationHandler.forMixinAnnotation(parentAnnotation) ?: return
-                    val targets = handler.resolveTarget(parentAnnotation).ifEmpty { return }
+                    val targets = MixinAnnotationHandler.resolveTarget(parentAnnotation).ifEmpty { return }
                     val failure = targets.asSequence()
                         .mapNotNull {
                             (it as? MethodTargetMember)?.classAndMethod
diff --git a/src/main/kotlin/platform/mixin/inspection/injector/CancellableBeforeSuperCallInspection.kt b/src/main/kotlin/platform/mixin/inspection/injector/CancellableBeforeSuperCallInspection.kt
@@ -64,7 +64,7 @@ class CancellableBeforeSuperCallInspection : MixinInspection() {
             val handler = MixinAnnotationHandler.forMixinAnnotation(MixinConstants.Annotations.INJECT)!!
                 as InjectorAnnotationHandler
 
-            for (target in handler.resolveTarget(annotation)) {
+            for (target in MixinAnnotationHandler.resolveTarget(annotation)) {
                 if (target !is MethodTargetMember) {
                     continue
                 }
diff --git a/src/main/kotlin/platform/mixin/inspection/injector/CtorHeadPostInitInspection.kt b/src/main/kotlin/platform/mixin/inspection/injector/CtorHeadPostInitInspection.kt
@@ -57,8 +57,8 @@ class CtorHeadPostInitInspection : MixinInspection() {
             }
 
             val injectorAnnotation = AtResolver.findInjectorAnnotation(annotation) ?: return
-            val handler = MixinAnnotationHandler.forMixinAnnotation(injectorAnnotation, holder.project) ?: return
-            val targets = handler.resolveTarget(injectorAnnotation).filterIsInstance<MethodTargetMember>()
+            val targets = MixinAnnotationHandler.resolveTarget(injectorAnnotation)
+                .filterIsInstance<MethodTargetMember>()
 
             if (targets.any {
                 it.classAndMethod.method.isConstructor &&
diff --git a/src/main/kotlin/platform/mixin/inspection/injector/CtorHeadUsedForNonConstructorInspection.kt b/src/main/kotlin/platform/mixin/inspection/injector/CtorHeadUsedForNonConstructorInspection.kt
@@ -41,7 +41,7 @@ class CtorHeadUsedForNonConstructorInspection : MixinInspection() {
             if (atValue.constantValue != "CTOR_HEAD") {
                 return
             }
-            if (!UnnecessaryUnsafeInspection.mightTargetConstructor(holder.project, annotation)) {
+            if (!UnnecessaryUnsafeInspection.mightTargetConstructor(annotation)) {
                 holder.registerProblem(
                     atValue,
                     "CTOR_HEAD used without targeting a constructor",
diff --git a/src/main/kotlin/platform/mixin/inspection/injector/InjectCouldBeOverwriteInspection.kt b/src/main/kotlin/platform/mixin/inspection/injector/InjectCouldBeOverwriteInspection.kt
@@ -108,9 +108,9 @@ class InjectCouldBeOverwriteInspection : MixinInspection() {
             }
 
             // check there is only one target
-            val injectHandler = MixinAnnotationHandler.forMixinAnnotation(MixinConstants.Annotations.INJECT)!!
-            val targetMethod = (injectHandler.resolveTarget(injectAnnotation).singleOrNull() as? MethodTargetMember)
-                ?.classAndMethod ?: return
+            val targetMethod =
+                (MixinAnnotationHandler.resolveTarget(injectAnnotation).singleOrNull() as? MethodTargetMember)
+                    ?.classAndMethod ?: return
 
             // can't overwrite constructors / static initializers
             if (targetMethod.method.isConstructor || targetMethod.method.isClinit) {
diff --git a/src/main/kotlin/platform/mixin/inspection/injector/InjectIntoConstructorInspection.kt b/src/main/kotlin/platform/mixin/inspection/injector/InjectIntoConstructorInspection.kt
@@ -20,7 +20,6 @@
 
 package com.demonwav.mcdev.platform.mixin.inspection.injector
 
-import com.demonwav.mcdev.platform.mixin.handlers.InjectorAnnotationHandler
 import com.demonwav.mcdev.platform.mixin.handlers.MixinAnnotationHandler
 import com.demonwav.mcdev.platform.mixin.handlers.injectionPoint.AtResolver
 import com.demonwav.mcdev.platform.mixin.inspection.MixinInspection
@@ -64,8 +63,7 @@ class InjectIntoConstructorInspection : MixinInspection() {
             override fun visitMethod(method: PsiMethod) {
                 val injectAnnotation = method.findAnnotation(INJECT) ?: return
                 val problemElement = injectAnnotation.nameReferenceElement ?: return
-                val handler = MixinAnnotationHandler.forMixinAnnotation(INJECT) as? InjectorAnnotationHandler ?: return
-                val targets = handler.resolveTarget(injectAnnotation)
+                val targets = MixinAnnotationHandler.resolveTarget(injectAnnotation)
 
                 val ats = injectAnnotation.findDeclaredAttributeValue("at")
                     ?.findAnnotations()
diff --git a/src/main/kotlin/platform/mixin/inspection/injector/ModifyVariableArgsOnlyInspection.kt b/src/main/kotlin/platform/mixin/inspection/injector/ModifyVariableArgsOnlyInspection.kt
@@ -51,8 +51,7 @@ class ModifyVariableArgsOnlyInspection : MixinInspection() {
                 val wantedType = method.parameterList.getParameter(0)?.type ?: return
                 val problemElement = modifyVariable.nameReferenceElement ?: return
 
-                val handler = MixinAnnotationHandler.forMixinAnnotation(MODIFY_VARIABLE) ?: return
-                val targets = handler.resolveTarget(modifyVariable).ifEmpty { return }
+                val targets = MixinAnnotationHandler.resolveTarget(modifyVariable).ifEmpty { return }
                 val methodTargets = targets.asSequence()
                     .filterIsInstance<MethodTargetMember>()
                     .map { it.classAndMethod }
diff --git a/src/main/kotlin/platform/mixin/inspection/injector/UnnecessaryUnsafeInspection.kt b/src/main/kotlin/platform/mixin/inspection/injector/UnnecessaryUnsafeInspection.kt
@@ -32,7 +32,6 @@ import com.demonwav.mcdev.util.constantValue
 import com.demonwav.mcdev.util.findInspection
 import com.demonwav.mcdev.util.ifEmpty
 import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.openapi.project.Project
 import com.intellij.psi.JavaElementVisitor
 import com.intellij.psi.PsiAnnotation
 import com.intellij.psi.PsiElementVisitor
@@ -81,7 +80,7 @@ class UnnecessaryUnsafeInspection : MixinInspection() {
                     return
                 }
 
-                if (alwaysUnnecessary || !mightTargetConstructor(holder.project, annotation)) {
+                if (alwaysUnnecessary || !mightTargetConstructor(annotation)) {
                     holder.registerProblem(
                         unsafeValue,
                         "Unnecessary unsafe = true",
@@ -93,11 +92,10 @@ class UnnecessaryUnsafeInspection : MixinInspection() {
     }
 
     companion object {
-        fun mightTargetConstructor(project: Project, at: PsiAnnotation): Boolean {
+        fun mightTargetConstructor(at: PsiAnnotation): Boolean {
             val injectorAnnotation = AtResolver.findInjectorAnnotation(at) ?: return true
-            val handler = MixinAnnotationHandler.forMixinAnnotation(injectorAnnotation, project) ?: return true
 
-            val targets = handler.resolveTarget(injectorAnnotation)
+            val targets = MixinAnnotationHandler.resolveTarget(injectorAnnotation)
                 .filterIsInstance<MethodTargetMember>()
                 .ifEmpty { return true }
 
diff --git a/src/main/kotlin/platform/mixin/inspection/mixinextras/LocalArgsOnlyInspection.kt b/src/main/kotlin/platform/mixin/inspection/mixinextras/LocalArgsOnlyInspection.kt
@@ -53,9 +53,7 @@ class LocalArgsOnlyInspection : MixinInspection() {
             val method = parameter.findContainingMethod() ?: return
 
             val targets = method.annotations.mapFirstNotNull { annotation ->
-                val handler = MixinAnnotationHandler.forMixinAnnotation(annotation, holder.project)
-                    ?: return@mapFirstNotNull null
-                handler.resolveTarget(annotation).asSequence()
+                MixinAnnotationHandler.resolveTarget(annotation).asSequence()
                     .filterIsInstance<MethodTargetMember>()
                     .map { it.classAndMethod }
             } ?: return
diff --git a/src/main/kotlin/platform/mixin/inspection/overwrite/OverwriteModifiersInspection.kt b/src/main/kotlin/platform/mixin/inspection/overwrite/OverwriteModifiersInspection.kt
@@ -20,7 +20,7 @@
 
 package com.demonwav.mcdev.platform.mixin.inspection.overwrite
 
-import com.demonwav.mcdev.platform.mixin.handlers.OverwriteHandler
+import com.demonwav.mcdev.platform.mixin.handlers.MixinAnnotationHandler
 import com.demonwav.mcdev.platform.mixin.util.MethodTargetMember
 import com.demonwav.mcdev.platform.mixin.util.MixinConstants.Annotations.OVERWRITE
 import com.demonwav.mcdev.platform.mixin.util.accessLevel
@@ -47,8 +47,7 @@ class OverwriteModifiersInspection : OverwriteInspection() {
 
     override fun visitOverwrite(holder: ProblemsHolder, method: PsiMethod, overwrite: PsiAnnotation) {
         val overwriteAnnotation = method.getAnnotation(OVERWRITE) ?: return
-        val overwriteHandler = OverwriteHandler.getInstance() ?: return
-        val target = (overwriteHandler.resolveTarget(overwriteAnnotation).firstOrNull() as? MethodTargetMember)
+        val target = (MixinAnnotationHandler.resolveTarget(overwriteAnnotation).firstOrNull() as? MethodTargetMember)
             ?.classAndMethod ?: return
         val nameIdentifier = method.nameIdentifier ?: return
         val modifierList = method.modifierList
diff --git a/src/main/kotlin/platform/mixin/inspection/shadow/ShadowModifiersInspection.kt b/src/main/kotlin/platform/mixin/inspection/shadow/ShadowModifiersInspection.kt
@@ -20,7 +20,7 @@
 
 package com.demonwav.mcdev.platform.mixin.inspection.shadow
 
-import com.demonwav.mcdev.platform.mixin.handlers.ShadowHandler
+import com.demonwav.mcdev.platform.mixin.handlers.MixinAnnotationHandler
 import com.demonwav.mcdev.platform.mixin.inspection.MixinInspection
 import com.demonwav.mcdev.platform.mixin.util.FieldTargetMember
 import com.demonwav.mcdev.platform.mixin.util.MethodTargetMember
@@ -61,7 +61,7 @@ class ShadowModifiersInspection : MixinInspection() {
 
             val shadowModifierList = annotation.owner as? PsiModifierList ?: return
             val member = shadowModifierList.parent as? PsiMember ?: return
-            val target = ShadowHandler.getInstance()?.resolveTarget(annotation)?.firstOrNull() ?: return
+            val target = MixinAnnotationHandler.resolveTarget(annotation).firstOrNull() ?: return
 
             // Check static modifier
             val targetStatic = (target.access and Opcodes.ACC_STATIC) != 0
diff --git a/src/main/kotlin/platform/mixin/reference/AccessorReference.kt b/src/main/kotlin/platform/mixin/reference/AccessorReference.kt
@@ -20,7 +20,7 @@
 
 package com.demonwav.mcdev.platform.mixin.reference
 
-import com.demonwav.mcdev.platform.mixin.handlers.AccessorHandler
+import com.demonwav.mcdev.platform.mixin.handlers.MixinAnnotationHandler
 import com.demonwav.mcdev.platform.mixin.util.MixinConstants
 import com.demonwav.mcdev.platform.mixin.util.findFieldByName
 import com.demonwav.mcdev.platform.mixin.util.findOrConstructSourceField
@@ -58,9 +58,8 @@ object AccessorReference : PolyReferenceResolver() {
                 it.findFieldByName(name)?.findSourceField(it, project, context.resolveScope, canDecompile = false)
             }.toResolveResults()
         } else {
-            val handler = AccessorHandler.getInstance() ?: return ResolveResult.EMPTY_ARRAY
             val annotation = context.parentOfType<PsiAnnotation>() ?: return ResolveResult.EMPTY_ARRAY
-            handler.resolveTarget(annotation).asSequence()
+            MixinAnnotationHandler.resolveTarget(annotation).asSequence()
                 .mapNotNull { it.findSourceElement(project, context.resolveScope, canDecompile = false) }
                 .toResolveResults()
         }
diff --git a/src/main/kotlin/platform/mixin/reference/InvokerReference.kt b/src/main/kotlin/platform/mixin/reference/InvokerReference.kt
@@ -20,7 +20,7 @@
 
 package com.demonwav.mcdev.platform.mixin.reference
 
-import com.demonwav.mcdev.platform.mixin.handlers.InvokerHandler
+import com.demonwav.mcdev.platform.mixin.handlers.MixinAnnotationHandler
 import com.demonwav.mcdev.platform.mixin.util.MixinConstants
 import com.demonwav.mcdev.platform.mixin.util.findOrConstructSourceMethod
 import com.demonwav.mcdev.platform.mixin.util.findSourceElement
@@ -64,9 +64,8 @@ object InvokerReference : PolyReferenceResolver() {
                 } ?: emptyList()
             }.toResolveResults()
         } else {
-            val handler = InvokerHandler.getInstance() ?: return ResolveResult.EMPTY_ARRAY
             val annotation = context.parentOfType<PsiAnnotation>() ?: return ResolveResult.EMPTY_ARRAY
-            handler.resolveTarget(annotation).asSequence()
+            MixinAnnotationHandler.resolveTarget(annotation).asSequence()
                 .mapNotNull { it.findSourceElement(project, context.resolveScope, canDecompile = false) }
                 .toResolveResults()
         }
diff --git a/src/main/kotlin/platform/mixin/reference/target/DefinitionReferences.kt b/src/main/kotlin/platform/mixin/reference/target/DefinitionReferences.kt
@@ -31,7 +31,6 @@ import com.demonwav.mcdev.util.findContainingModifierList
 import com.demonwav.mcdev.util.findField
 import com.demonwav.mcdev.util.findMethods
 import com.demonwav.mcdev.util.insideAnnotationAttribute
-import com.demonwav.mcdev.util.mapFirstNotNull
 import com.demonwav.mcdev.util.mapToArray
 import com.demonwav.mcdev.util.reference.PolyReferenceResolver
 import com.demonwav.mcdev.util.toTypedArray
@@ -96,14 +95,13 @@ abstract class AbstractDefinitionReference : PolyReferenceResolver(), MixinRefer
     private fun resolveInBytecode(context: PsiElement, memberReference: MemberReference): List<MemberReference> {
         val project = context.project
         val modifierList = context.findContainingModifierList() ?: return emptyList()
-        val (annotation, handler) = modifierList.annotations.mapFirstNotNull { annotation ->
-            val handler = MixinAnnotationHandler.forMixinAnnotation(annotation, project) ?: return@mapFirstNotNull null
-            annotation to handler
+        val annotation = modifierList.annotations.firstOrNull {
+            MixinAnnotationHandler.forMixinAnnotation(it, project) != null
         } ?: return emptyList()
 
         val result = mutableListOf<MemberReference>()
 
-        for (target in handler.resolveTarget(annotation)) {
+        for (target in MixinAnnotationHandler.resolveTarget(annotation)) {
             if (target !is MethodTargetMember) {
                 continue
             }
diff --git a/src/main/kotlin/platform/mixin/reference/target/TargetReference.kt b/src/main/kotlin/platform/mixin/reference/target/TargetReference.kt
