mixin: Use TargetReference to properly resolve targets in folding builder

Fixes #278

Author: stephan-gh

src/main/kotlin/com/demonwav/mcdev/platform/mixin/folding/MixinFoldingBuilder.kt

@@ -11,12 +11,12 @@
 package com.demonwav.mcdev.platform.mixin.folding
 
 import com.demonwav.mcdev.platform.mixin.MixinModuleType
+import com.demonwav.mcdev.platform.mixin.reference.target.TargetReference
 import com.demonwav.mcdev.platform.mixin.util.MixinConstants.Annotations.AT
-import com.demonwav.mcdev.platform.mixin.util.MixinMemberReference
-import com.demonwav.mcdev.util.constantStringValue
 import com.intellij.lang.ASTNode
 import com.intellij.lang.folding.CustomFoldingBuilder
 import com.intellij.lang.folding.FoldingDescriptor
+import com.intellij.navigation.NavigationItem
 import com.intellij.openapi.editor.Document
 import com.intellij.openapi.util.TextRange
 import com.intellij.psi.CommonClassNames
@@ -50,27 +50,25 @@ class MixinFoldingBuilder : CustomFoldingBuilder() {
         }
     }
 
+    private fun formatElement(element: PsiElement): String? {
+        return when (element) {
+            is PsiMethod -> PsiFormatUtil.formatMethod(element, PsiSubstitutor.EMPTY,
+                PsiFormatUtilBase.SHOW_NAME or PsiFormatUtilBase.SHOW_PARAMETERS or SHOW_CONTAINING_CLASS,
+                PsiFormatUtilBase.SHOW_TYPE)
+            is PsiVariable -> PsiFormatUtil.formatVariable(element,
+                PsiFormatUtilBase.SHOW_NAME or SHOW_CONTAINING_CLASS, PsiSubstitutor.EMPTY)
+            is NavigationItem -> element.presentation?.presentableText
+            else -> null
+        }
+    }
+
     override fun getLanguagePlaceholderText(node: ASTNode, range: TextRange): String {
         val element = node.psi
-        when (element) {
-            is PsiTypeCastExpression -> {
-                val castText = element.castType?.text ?: return node.text
-                return "($castText)"
-            }
-            is PsiAnnotationMemberValue -> {
-                val value = element.constantStringValue ?: return node.text
-                val member = MixinMemberReference.parse(value)?.resolveMember(element.project, element.resolveScope) ?: return node.text
-                return when (member) {
-                    is PsiMethod -> PsiFormatUtil.formatMethod(member, PsiSubstitutor.EMPTY,
-                        PsiFormatUtilBase.SHOW_NAME or PsiFormatUtilBase.SHOW_PARAMETERS or SHOW_CONTAINING_CLASS,
-                        PsiFormatUtilBase.SHOW_TYPE)
-                    is PsiVariable -> PsiFormatUtil.formatVariable(member, PsiFormatUtilBase.SHOW_NAME or SHOW_CONTAINING_CLASS, PsiSubstitutor.EMPTY)
-                    else -> member.presentation?.presentableText ?: node.text
-                }
-            }
+        return when (element) {
+            is PsiTypeCastExpression -> "(${element.castType?.text ?: return node.text})"
+            is PsiAnnotationMemberValue -> TargetReference.resolveTarget(element)?.let { formatElement(it) } ?: node.text
+            else -> node.text
         }
-
-        return node.text
     }
 
     override fun buildLanguageFoldRegions(descriptors: MutableList<FoldingDescriptor>, root: PsiElement, document: Document, quick: Boolean) {

src/main/kotlin/com/demonwav/mcdev/platform/mixin/reference/target/ConstructorTargetReference.kt

@@ -11,6 +11,7 @@
 package com.demonwav.mcdev.platform.mixin.reference.target
 
 import com.demonwav.mcdev.util.constantStringValue
+import com.demonwav.mcdev.util.findQualifiedClass
 import com.demonwav.mcdev.util.internalName
 import com.demonwav.mcdev.util.shortName
 import com.intellij.codeInsight.completion.JavaLookupElementBuilder
@@ -21,6 +22,11 @@ import com.intellij.psi.PsiNewExpression
 
 object ConstructorTargetReference : TargetReference.Handler<PsiClass>() {
 
+    override fun resolveTarget(context: PsiElement): PsiElement? {
+        val name = context.constantStringValue?.replace('/', '.') ?: return null
+        return findQualifiedClass(name, context)
+    }
+
     override fun createFindUsagesVisitor(context: PsiElement, targetClass: PsiClass, checkOnly: Boolean): CollectVisitor<out PsiElement>? {
         val name = context.constantStringValue?.replace('/', '.') ?: return null
         return FindUsagesVisitor(name, checkOnly)

src/main/kotlin/com/demonwav/mcdev/platform/mixin/reference/target/TargetReference.kt

@@ -67,6 +67,11 @@ object TargetReference : PolyReferenceResolver(), MixinReference {
         return handler.usesMemberReference()
     }
 
+    fun resolveTarget(context: PsiElement): PsiElement? {
+        val handler = getHandler(context.annotationFromValue ?: return null) ?: return null
+        return handler.resolveTarget(context)
+    }
+
     private fun getTargetMethod(at: PsiAnnotation): PsiMethod? {
         // TODO: Right now this will only work for Mixins with a single target class
         val methodValue = at.annotationFromArrayValue?.findDeclaredAttributeValue("method") ?: return null
@@ -116,6 +121,8 @@ object TargetReference : PolyReferenceResolver(), MixinReference {
 
         open fun usesMemberReference() = false
 
+        abstract fun resolveTarget(context: PsiElement): PsiElement?
+
         abstract fun createFindUsagesVisitor(context: PsiElement, targetClass: PsiClass,
                                                       checkOnly: Boolean): CollectVisitor<out PsiElement>?
         abstract fun createCollectUsagesVisitor(): CollectVisitor<T>
@@ -129,6 +136,11 @@ object TargetReference : PolyReferenceResolver(), MixinReference {
 
         protected abstract fun createLookup(targetClass: PsiClass, m: T, owner: PsiClass): LookupElementBuilder
 
+        override open fun resolveTarget(context: PsiElement): PsiElement? {
+            val value = context.constantStringValue ?: return null
+            return MixinMemberReference.parse(value)?.resolveMember(context.project, context.resolveScope)
+        }
+
         protected open fun getInternalName(m: QualifiedMember<T>): String {
             return m.member.name!!
         }

src/main/kotlin/com/demonwav/mcdev/util/MemberReference.kt

@@ -62,7 +62,11 @@ data class MemberReference(val name: String, val descriptor: String? = null,
 
     @Contract(pure = true)
     private inline fun <R> resolve(project: Project, scope: GlobalSearchScope, ret: (PsiClass, PsiMember) -> R): R? {
-        val psiClass = findQualifiedClass(project, this.owner!!, scope) ?: return null
+        if (this.owner == null) {
+            throw IllegalStateException("Cannot resolve unqualified member reference (owner == null)")
+        }
+
+        val psiClass = findQualifiedClass(project, this.owner, scope) ?: return null
 
         val member: PsiMember? = if (descriptor != null && descriptor.startsWith('(')) {
             // Method, we assume there is only one (since this member descriptor is full qualified)