Add MixinAnnotationHandler.forMixinAnnotation(PsiAnnotation) and cleanup usages

Earthcomputer · Earthcomputer · commit 7969d538cf65 · 2025-02-25T13:15:25.000Z
diff --git a/src/main/kotlin/platform/mixin/expression/MEExpressionCompletionUtil.kt b/src/main/kotlin/platform/mixin/expression/MEExpressionCompletionUtil.kt
@@ -247,8 +247,7 @@ object MEExpressionCompletionUtil {
         val modifierList = expressionAnnotation.findContainingModifierList() ?: return emptyList()
 
         val (handler, handlerAnnotation) = modifierList.annotations.mapFirstNotNull { annotation ->
-            val qName = annotation.qualifiedName ?: return@mapFirstNotNull null
-            val handler = MixinAnnotationHandler.forMixinAnnotation(qName, project) ?: return@mapFirstNotNull null
+            val handler = MixinAnnotationHandler.forMixinAnnotation(annotation, project) ?: return@mapFirstNotNull null
             handler to annotation
         } ?: return emptyList()
 
@@ -285,8 +284,7 @@ object MEExpressionCompletionUtil {
         val mixinClass = modifierList.findContainingClass() ?: return emptyList()
 
         val (handler, handlerAnnotation) = modifierList.annotations.mapFirstNotNull { annotation ->
-            val qName = annotation.qualifiedName ?: return@mapFirstNotNull null
-            val handler = MixinAnnotationHandler.forMixinAnnotation(qName, project) ?: return@mapFirstNotNull null
+            val handler = MixinAnnotationHandler.forMixinAnnotation(annotation, project) ?: return@mapFirstNotNull null
             handler to annotation
         } ?: return emptyList()
 
diff --git a/src/main/kotlin/platform/mixin/handlers/MixinAnnotationHandler.kt b/src/main/kotlin/platform/mixin/handlers/MixinAnnotationHandler.kt
@@ -96,6 +96,11 @@ interface MixinAnnotationHandler {
         fun getBuiltinHandlers(): Sequence<Pair<String, MixinAnnotationHandler>> =
             EP_NAME.extensions.asSequence().map { it.key to it.instance }
 
+        fun forMixinAnnotation(annotation: PsiAnnotation, project: Project = annotation.project): MixinAnnotationHandler? {
+            val qName = annotation.qualifiedName ?: return null
+            return forMixinAnnotation(qName, project)
+        }
+
         fun forMixinAnnotation(qualifiedName: String, project: Project? = null): MixinAnnotationHandler? {
             val extension = COLLECTOR.findSingle(qualifiedName)
             if (extension != null) {
diff --git a/src/main/kotlin/platform/mixin/handlers/injectionPoint/ConstantInjectionPoint.kt b/src/main/kotlin/platform/mixin/handlers/injectionPoint/ConstantInjectionPoint.kt
@@ -87,8 +87,7 @@ 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 = injectorAnnotation.qualifiedName
-                ?.let { MixinAnnotationHandler.forMixinAnnotation(it, at.project) }
+            val handler = MixinAnnotationHandler.forMixinAnnotation(injectorAnnotation)
                 ?: return ArrayUtilRt.EMPTY_OBJECT_ARRAY
 
             val expandConditions = parseExpandConditions(AtResolver.getArgs(at))
diff --git a/src/main/kotlin/platform/mixin/handlers/injectionPoint/ConstantStringMethodInjectionPoint.kt b/src/main/kotlin/platform/mixin/handlers/injectionPoint/ConstantStringMethodInjectionPoint.kt
@@ -99,8 +99,7 @@ class ConstantStringMethodInjectionPoint : AbstractMethodInjectionPoint() {
         }
 
         val injectorAnnotation = AtResolver.findInjectorAnnotation(at) ?: return ArrayUtilRt.EMPTY_OBJECT_ARRAY
-        val handler = injectorAnnotation.qualifiedName
-            ?.let { MixinAnnotationHandler.forMixinAnnotation(it, at.project) }
+        val handler = MixinAnnotationHandler.forMixinAnnotation(injectorAnnotation)
             ?: return ArrayUtilRt.EMPTY_OBJECT_ARRAY
 
         return handler.resolveTarget(injectorAnnotation).asSequence()
diff --git a/src/main/kotlin/platform/mixin/handlers/injectionPoint/NewInsnInjectionPoint.kt b/src/main/kotlin/platform/mixin/handlers/injectionPoint/NewInsnInjectionPoint.kt
@@ -70,8 +70,7 @@ class NewInsnInjectionPoint : InjectionPoint<PsiMember>() {
         }
 
         val injectorAnnotation = AtResolver.findInjectorAnnotation(at) ?: return ArrayUtilRt.EMPTY_OBJECT_ARRAY
-        val handler = injectorAnnotation.qualifiedName
-            ?.let { MixinAnnotationHandler.forMixinAnnotation(it, at.project) }
+        val handler = MixinAnnotationHandler.forMixinAnnotation(injectorAnnotation)
             ?: return ArrayUtilRt.EMPTY_OBJECT_ARRAY
 
         return handler.resolveTarget(injectorAnnotation).asSequence()
diff --git a/src/main/kotlin/platform/mixin/insight/MixinElementLineMarkerProvider.kt b/src/main/kotlin/platform/mixin/insight/MixinElementLineMarkerProvider.kt
@@ -64,9 +64,7 @@ class MixinElementLineMarkerProvider : LineMarkerProviderDescriptor() {
         } ?: return null
 
         val (handler, annotation) = element.annotations.mapFirstNotNull { annotation ->
-            annotation.qualifiedName?.let { qName ->
-                MixinAnnotationHandler.forMixinAnnotation(qName, annotation.project)?.let { it to annotation }
-            }
+            MixinAnnotationHandler.forMixinAnnotation(annotation)?.let { it to annotation }
         } ?: return null
         if (handler.isUnresolved(annotation) != null) {
             return null
diff --git a/src/main/kotlin/platform/mixin/insight/MixinEntryPoint.kt b/src/main/kotlin/platform/mixin/insight/MixinEntryPoint.kt
@@ -60,8 +60,7 @@ class MixinEntryPoint : EntryPointWithVisibilityLevel() {
         }
         val project = member.project
         for (annotation in member.annotations) {
-            val qName = annotation.qualifiedName ?: continue
-            val handler = MixinAnnotationHandler.forMixinAnnotation(qName, project)
+            val handler = MixinAnnotationHandler.forMixinAnnotation(annotation, project)
             if (handler is InjectorAnnotationHandler) {
                 return PsiUtil.ACCESS_LEVEL_PRIVATE
             }
diff --git a/src/main/kotlin/platform/mixin/inspection/MixinAnnotationTargetInspection.kt b/src/main/kotlin/platform/mixin/inspection/MixinAnnotationTargetInspection.kt
@@ -43,18 +43,15 @@ class MixinAnnotationTargetInspection : MixinInspection() {
                 if (qName == AT) {
                     var parentAnnotation = annotation.parentOfType<PsiAnnotation>()
                     while (parentAnnotation != null) {
-                        val parentQName = parentAnnotation.qualifiedName ?: return
-                        if (MixinAnnotationHandler.forMixinAnnotation(parentQName, parentAnnotation.project) != null) {
+                        if (MixinAnnotationHandler.forMixinAnnotation(parentAnnotation) != null) {
                             break
                         }
                         parentAnnotation = parentAnnotation.parentOfType()
                     }
                     if (parentAnnotation == null) {
                         return
                     }
-                    val parentQName = parentAnnotation.qualifiedName ?: return
-                    val handler = MixinAnnotationHandler.forMixinAnnotation(parentQName, parentAnnotation.project)
-                        ?: return
+                    val handler = MixinAnnotationHandler.forMixinAnnotation(parentAnnotation) ?: return
                     val targets = handler.resolveTarget(parentAnnotation).ifEmpty { return }
                     val failure = targets.asSequence()
                         .mapNotNull {
diff --git a/src/main/kotlin/platform/mixin/inspection/MixinAnnotationsInspection.kt b/src/main/kotlin/platform/mixin/inspection/MixinAnnotationsInspection.kt
@@ -40,8 +40,7 @@ class MixinAnnotationsInspection : MixinInspection() {
     private class Visitor(private val holder: ProblemsHolder) : JavaElementVisitor() {
 
         override fun visitAnnotation(annotation: PsiAnnotation) {
-            val qualifiedName = annotation.qualifiedName ?: return
-            if (MixinAnnotationHandler.forMixinAnnotation(qualifiedName, annotation.project) == null) {
+            if (MixinAnnotationHandler.forMixinAnnotation(annotation, annotation.project) == null) {
                 return
             }
 
diff --git a/src/main/kotlin/platform/mixin/inspection/injector/CtorHeadPostInitInspection.kt b/src/main/kotlin/platform/mixin/inspection/injector/CtorHeadPostInitInspection.kt
@@ -57,9 +57,7 @@ class CtorHeadPostInitInspection : MixinInspection() {
             }
 
             val injectorAnnotation = AtResolver.findInjectorAnnotation(annotation) ?: return
-            val handler = injectorAnnotation.qualifiedName
-                ?.let { MixinAnnotationHandler.forMixinAnnotation(it, holder.project) }
-                ?: return
+            val handler = MixinAnnotationHandler.forMixinAnnotation(injectorAnnotation, holder.project) ?: return
             val targets = handler.resolveTarget(injectorAnnotation).filterIsInstance<MethodTargetMember>()
 
             if (targets.any {
diff --git a/src/main/kotlin/platform/mixin/inspection/injector/InvalidInjectorMethodSignatureInspection.kt b/src/main/kotlin/platform/mixin/inspection/injector/InvalidInjectorMethodSignatureInspection.kt
@@ -95,8 +95,7 @@ class InvalidInjectorMethodSignatureInspection : MixinInspection() {
             var reportedSignature = false
 
             for (annotation in modifiers.annotations) {
-                val qName = annotation.qualifiedName ?: continue
-                val handler = MixinAnnotationHandler.forMixinAnnotation(qName, annotation.project)
+                val handler = MixinAnnotationHandler.forMixinAnnotation(annotation, annotation.project)
                     as? InjectorAnnotationHandler ?: continue
                 val methodAttribute = annotation.findDeclaredAttributeValue("method") ?: continue
                 val targetMethods = MethodReference.resolveAllIfNotAmbiguous(methodAttribute) ?: continue
diff --git a/src/main/kotlin/platform/mixin/inspection/injector/UnnecessaryUnsafeInspection.kt b/src/main/kotlin/platform/mixin/inspection/injector/UnnecessaryUnsafeInspection.kt
@@ -95,9 +95,7 @@ class UnnecessaryUnsafeInspection : MixinInspection() {
     companion object {
         fun mightTargetConstructor(project: Project, at: PsiAnnotation): Boolean {
             val injectorAnnotation = AtResolver.findInjectorAnnotation(at) ?: return true
-            val handler = injectorAnnotation.qualifiedName?.let {
-                MixinAnnotationHandler.forMixinAnnotation(it, project)
-            } ?: return true
+            val handler = MixinAnnotationHandler.forMixinAnnotation(injectorAnnotation, project) ?: return true
 
             val targets = handler.resolveTarget(injectorAnnotation)
                 .filterIsInstance<MethodTargetMember>()
diff --git a/src/main/kotlin/platform/mixin/inspection/mixinextras/LocalArgsOnlyInspection.kt b/src/main/kotlin/platform/mixin/inspection/mixinextras/LocalArgsOnlyInspection.kt
@@ -53,8 +53,7 @@ class LocalArgsOnlyInspection : MixinInspection() {
             val method = parameter.findContainingMethod() ?: return
 
             val targets = method.annotations.mapFirstNotNull { annotation ->
-                val qName = annotation.qualifiedName ?: return@mapFirstNotNull null
-                val handler = MixinAnnotationHandler.forMixinAnnotation(qName, holder.project)
+                val handler = MixinAnnotationHandler.forMixinAnnotation(annotation, holder.project)
                     ?: return@mapFirstNotNull null
                 handler.resolveTarget(annotation).asSequence()
                     .filterIsInstance<MethodTargetMember>()
diff --git a/src/main/kotlin/platform/mixin/inspection/mixinextras/UnnecessaryMutableLocalInspection.kt b/src/main/kotlin/platform/mixin/inspection/mixinextras/UnnecessaryMutableLocalInspection.kt
@@ -54,7 +54,7 @@ class UnnecessaryMutableLocalInspection : MixinInspection() {
         override fun visitMethod(method: PsiMethod) {
             val project = method.project
             val hasValidMixinAnnotation = method.annotations.any { ann ->
-                ann.qualifiedName?.let { MixinAnnotationHandler.forMixinAnnotation(it, project) }
+                MixinAnnotationHandler.forMixinAnnotation(ann, project)
                     // Mutable Local references do have different semantics inside a WrapOperation.
                     ?.let { it is InjectorAnnotationHandler && it !is WrapOperationHandler } == true
             }
diff --git a/src/main/kotlin/platform/mixin/inspection/mixinextras/UnresolvedLocalCaptureInspection.kt b/src/main/kotlin/platform/mixin/inspection/mixinextras/UnresolvedLocalCaptureInspection.kt
@@ -49,9 +49,8 @@ class UnresolvedLocalCaptureInspection : MixinInspection() {
             val parameter = localAnnotation.parentOfType<PsiParameter>() ?: return
             val method = parameter.findContainingMethod() ?: return
             val targets = method.annotations.mapFirstNotNull { annotation ->
-                val qName = annotation.qualifiedName ?: return@mapFirstNotNull null
                 val handler =
-                    MixinAnnotationHandler.forMixinAnnotation(qName, holder.project) as? InjectorAnnotationHandler
+                    MixinAnnotationHandler.forMixinAnnotation(annotation, holder.project) as? InjectorAnnotationHandler
                         ?: return@mapFirstNotNull null
                 handler.resolveInstructions(annotation)
             } ?: return
diff --git a/src/main/kotlin/platform/mixin/inspection/reference/AmbiguousReferenceInspection.kt b/src/main/kotlin/platform/mixin/inspection/reference/AmbiguousReferenceInspection.kt
@@ -45,8 +45,7 @@ class AmbiguousReferenceInspection : MixinAnnotationAttributeInspection("method"
         value: PsiAnnotationMemberValue,
         holder: ProblemsHolder,
     ) {
-        val qName = annotation.qualifiedName ?: return
-        val handler = MixinAnnotationHandler.forMixinAnnotation(qName, annotation.project)
+        val handler = MixinAnnotationHandler.forMixinAnnotation(annotation)
         if (handler !is InjectorAnnotationHandler || handler.isSoft) {
             return
         }
diff --git a/src/main/kotlin/platform/mixin/inspection/reference/UnnecessaryQualifiedMemberReferenceInspection.kt b/src/main/kotlin/platform/mixin/inspection/reference/UnnecessaryQualifiedMemberReferenceInspection.kt
@@ -44,8 +44,7 @@ class UnnecessaryQualifiedMemberReferenceInspection : MixinAnnotationAttributeIn
         value: PsiAnnotationMemberValue,
         holder: ProblemsHolder,
     ) {
-        val qName = annotation.qualifiedName ?: return
-        if (MixinAnnotationHandler.forMixinAnnotation(qName, annotation.project) !is InjectorAnnotationHandler) {
+        if (MixinAnnotationHandler.forMixinAnnotation(annotation) !is InjectorAnnotationHandler) {
             return
         }
 
diff --git a/src/main/kotlin/platform/mixin/reference/AbstractMethodReference.kt b/src/main/kotlin/platform/mixin/reference/AbstractMethodReference.kt
@@ -72,10 +72,8 @@ abstract class AbstractMethodReference : PolyReferenceResolver(), MixinReference
 
     override fun isUnresolved(context: PsiElement): Boolean {
         // check if the annotation handler is soft
-        val annotationQName = context.parentOfType<PsiAnnotation>()?.qualifiedName
-        if (annotationQName != null &&
-            MixinAnnotationHandler.forMixinAnnotation(annotationQName, context.project)?.isSoft == true
-        ) {
+        val annotation = context.parentOfType<PsiAnnotation>()
+        if (annotation != null && MixinAnnotationHandler.forMixinAnnotation(annotation)?.isSoft == true) {
             return false
         }
 
diff --git a/src/main/kotlin/platform/mixin/reference/target/DefinitionReferences.kt b/src/main/kotlin/platform/mixin/reference/target/DefinitionReferences.kt
@@ -97,8 +97,7 @@ abstract class AbstractDefinitionReference : PolyReferenceResolver(), MixinRefer
         val project = context.project
         val modifierList = context.findContainingModifierList() ?: return emptyList()
         val (annotation, handler) = modifierList.annotations.mapFirstNotNull { annotation ->
-            val qName = annotation.qualifiedName ?: return@mapFirstNotNull null
-            val handler = MixinAnnotationHandler.forMixinAnnotation(qName, project) ?: return@mapFirstNotNull null
+            val handler = MixinAnnotationHandler.forMixinAnnotation(annotation, project) ?: return@mapFirstNotNull null
             annotation to handler
         } ?: return emptyList()
 
diff --git a/src/main/kotlin/platform/mixin/reference/target/TargetReference.kt b/src/main/kotlin/platform/mixin/reference/target/TargetReference.kt
@@ -74,11 +74,8 @@ object TargetReference : PolyReferenceResolver(), MixinReference {
             .filterIsInstance<PsiAnnotation>()
             .flatMap { it.owner?.annotations?.asSequence() ?: emptySequence() }
             .mapNotNull { annotation ->
-                val qName = annotation.qualifiedName ?: return@mapNotNull null
-                (
-                    MixinAnnotationHandler.forMixinAnnotation(qName, annotation.project)
-                        as? InjectorAnnotationHandler
-                    )?.let { it to annotation }
+                (MixinAnnotationHandler.forMixinAnnotation(annotation) as? InjectorAnnotationHandler)
+                    ?.let { it to annotation }
             }.firstOrNull() ?: return null
         if (forUnresolved && handler.isSoft) {
             return null
diff --git a/src/main/kotlin/platform/mixin/util/Mixin.kt b/src/main/kotlin/platform/mixin/util/Mixin.kt
@@ -239,8 +239,7 @@ fun isMixinEntryPoint(element: PsiElement?): Boolean {
     }
     val project = element.project
     for (annotation in element.annotations) {
-        val qName = annotation.qualifiedName ?: continue
-        val handler = MixinAnnotationHandler.forMixinAnnotation(qName, project)
+        val handler = MixinAnnotationHandler.forMixinAnnotation(annotation, project)
         if (handler != null && handler.isEntryPoint) {
             return true
         }

Original file line number	Diff line number	Diff line change
`@@ -99,8 +99,7 @@ class ConstantStringMethodInjectionPoint : AbstractMethodInjectionPoint() {`
`99`	`99`	`}`
`100`	`100`
`101`	`101`	`val injectorAnnotation = AtResolver.findInjectorAnnotation(at) ?: return ArrayUtilRt.EMPTY_OBJECT_ARRAY`
`102`		`- val handler = injectorAnnotation.qualifiedName`
`103`		`- ?.let { MixinAnnotationHandler.forMixinAnnotation(it, at.project) }`
	`102`	`+ val handler = MixinAnnotationHandler.forMixinAnnotation(injectorAnnotation)`
`104`	`103`	`?: return ArrayUtilRt.EMPTY_OBJECT_ARRAY`
`105`	`104`
`106`	`105`	`return handler.resolveTarget(injectorAnnotation).asSequence()`
Original file line number	Diff line number	Diff line change
`@@ -70,8 +70,7 @@ class NewInsnInjectionPoint : InjectionPoint<PsiMember>() {`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`val injectorAnnotation = AtResolver.findInjectorAnnotation(at) ?: return ArrayUtilRt.EMPTY_OBJECT_ARRAY`
`73`		`- val handler = injectorAnnotation.qualifiedName`
`74`		`- ?.let { MixinAnnotationHandler.forMixinAnnotation(it, at.project) }`
	`73`	`+ val handler = MixinAnnotationHandler.forMixinAnnotation(injectorAnnotation)`
`75`	`74`	`?: return ArrayUtilRt.EMPTY_OBJECT_ARRAY`
`76`	`75`
`77`	`76`	`return handler.resolveTarget(injectorAnnotation).asSequence()`
Original file line number	Diff line number	Diff line change
`@@ -60,8 +60,7 @@ class MixinEntryPoint : EntryPointWithVisibilityLevel() {`
`60`	`60`	`}`
`61`	`61`	`val project = member.project`
`62`	`62`	`for (annotation in member.annotations) {`
`63`		`- val qName = annotation.qualifiedName ?: continue`
`64`		`- val handler = MixinAnnotationHandler.forMixinAnnotation(qName, project)`
	`63`	`+ val handler = MixinAnnotationHandler.forMixinAnnotation(annotation, project)`
`65`	`64`	`if (handler is InjectorAnnotationHandler) {`
`66`	`65`	`return PsiUtil.ACCESS_LEVEL_PRIVATE`
`67`	`66`	`}`
Original file line number	Diff line number	Diff line change
`@@ -40,8 +40,7 @@ class MixinAnnotationsInspection : MixinInspection() {`
`40`	`40`	`private class Visitor(private val holder: ProblemsHolder) : JavaElementVisitor() {`
`41`	`41`
`42`	`42`	`override fun visitAnnotation(annotation: PsiAnnotation) {`
`43`		`- val qualifiedName = annotation.qualifiedName ?: return`
`44`		`- if (MixinAnnotationHandler.forMixinAnnotation(qualifiedName, annotation.project) == null) {`
	`43`	`+ if (MixinAnnotationHandler.forMixinAnnotation(annotation, annotation.project) == null) {`
`45`	`44`	`return`
`46`	`45`	`}`
`47`	`46`
Original file line number	Diff line number	Diff line change
`@@ -57,9 +57,7 @@ class CtorHeadPostInitInspection : MixinInspection() {`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`val injectorAnnotation = AtResolver.findInjectorAnnotation(annotation) ?: return`
`60`		`- val handler = injectorAnnotation.qualifiedName`
`61`		`- ?.let { MixinAnnotationHandler.forMixinAnnotation(it, holder.project) }`
`62`		`- ?: return`
	`60`	`+ val handler = MixinAnnotationHandler.forMixinAnnotation(injectorAnnotation, holder.project) ?: return`
`63`	`61`	`val targets = handler.resolveTarget(injectorAnnotation).filterIsInstance<MethodTargetMember>()`
`64`	`62`
`65`	`63`	`if (targets.any {`