Jump to class definition in jar file

Author: xterao

src/main/kotlin/org/domaframework/doma/intellij/common/psi/PsiStaticElement.kt

@@ -15,8 +15,10 @@
  */
 package org.domaframework.doma.intellij.common.psi
 
+import com.intellij.psi.JavaPsiFacade
 import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiFile
+import com.intellij.psi.search.GlobalSearchScope
 import org.domaframework.doma.intellij.extension.getJavaClazz
 import org.domaframework.doma.intellij.psi.SqlElExpr
 import org.jetbrains.kotlin.idea.base.util.module
@@ -26,7 +28,7 @@ import org.jetbrains.kotlin.idea.base.util.module
  */
 class PsiStaticElement(
     elExprList: List<SqlElExpr>? = null,
-    originalFile: PsiFile,
+    private val originalFile: PsiFile,
 ) {
     private var fqdn = elExprList?.joinToString(".") { e -> e.text } ?: ""
     private val module = originalFile.module
@@ -38,5 +40,10 @@ class PsiStaticElement(
                 .substringBefore("@")
     }
 
-    fun getRefClazz(): PsiClass? = module?.getJavaClazz(true, fqdn)
+    fun getRefClazz(): PsiClass? =
+        module?.getJavaClazz(true, fqdn)
+            ?: JavaPsiFacade.getInstance(originalFile.project).findClass(
+                fqdn,
+                GlobalSearchScope.allScope(originalFile.project),
+            )
 }

src/main/kotlin/org/domaframework/doma/intellij/reference/SqlElIdExprReference.kt

@@ -71,10 +71,10 @@ class SqlElIdExprReference(
         startTime: Long,
         file: PsiFile,
     ): PsiElement? {
-        val targetElement = getBlockCommentElements(element)
-        if (targetElement.isEmpty()) return null
+        val targetElements = getBlockCommentElements(element)
+        if (targetElements.isEmpty()) return null
 
-        val topElm = targetElement.firstOrNull() as? PsiElement ?: return null
+        val topElm = targetElements.firstOrNull() as? PsiElement ?: return null
 
         if (topElm.prevSibling.elementType == SqlTypes.AT_SIGN) return null
 
@@ -92,14 +92,14 @@ class SqlElIdExprReference(
         val daoMethod = findDaoMethod(file) ?: return null
 
         return when (element.textOffset) {
-            targetElement.first().textOffset ->
+            targetElements.first().textOffset ->
                 getReferenceDaoMethodParameter(
                     daoMethod,
                     element,
                     startTime,
                 )
 
-            else -> getReferenceEntity(daoMethod, targetElement, startTime)
+            else -> getReferenceEntity(daoMethod, targetElements, startTime)
         }
     }
 
@@ -124,13 +124,13 @@ class SqlElIdExprReference(
 
     private fun getReferenceDaoMethodParameter(
         daoMethod: PsiMethod,
-        it: PsiElement,
+        bindElement: PsiElement,
         startTime: Long,
     ): PsiElement? {
         daoMethod
             .let { method ->
                 method.methodParameters.firstOrNull { param ->
-                    param.name == it.text
+                    param.name == bindElement.text
                 }
             }?.originalElement
             ?.let { originalElm ->

src/main/kotlin/org/domaframework/doma/intellij/reference/SqlElStaticFieldReference.kt

@@ -24,11 +24,14 @@ import com.intellij.psi.util.CachedValuesManager
 import com.intellij.psi.util.PsiModificationTracker
 import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.psi.util.PsiTypesUtil
+import com.intellij.psi.util.elementType
 import org.domaframework.doma.intellij.common.PluginLoggerUtil
 import org.domaframework.doma.intellij.common.isSupportFileType
 import org.domaframework.doma.intellij.common.psi.PsiParentClass
 import org.domaframework.doma.intellij.common.psi.PsiStaticElement
+import org.domaframework.doma.intellij.psi.SqlElIdExpr
 import org.domaframework.doma.intellij.psi.SqlElStaticFieldAccessExpr
+import org.domaframework.doma.intellij.psi.SqlTypes
 
 class SqlElStaticFieldReference(
     element: PsiElement,
@@ -73,37 +76,73 @@ class SqlElStaticFieldReference(
         // Jump from field or method to definition (assuming the top element is static)
         val staticAccessParent =
             PsiTreeUtil.getParentOfType(staticDirection, SqlElStaticFieldAccessExpr::class.java)
-        if (staticAccessParent != null) {
-            val firstChildText =
-                staticAccessParent.children
-                    .firstOrNull()
-                    ?.text ?: ""
-            val psiStaticElement =
-                PsiStaticElement(
-                    firstChildText,
-                    file,
-                )
-            val javaClazz = psiStaticElement.getRefClazz() ?: return null
-            val psiParentClass = PsiParentClass(PsiTypesUtil.getClassType(javaClazz))
-            psiParentClass.findField(elementName)?.let {
-                PluginLoggerUtil.countLogging(
-                    this::class.java.simpleName,
-                    "ReferenceStaticField",
-                    "Reference",
-                    startTime,
-                )
-                return it
-            }
-            psiParentClass.findMethod(elementName)?.let {
-                PluginLoggerUtil.countLogging(
-                    this::class.java.simpleName,
-                    "ReferenceStaticMethod",
-                    "Reference",
-                    startTime,
-                )
-                return it
+        if (staticAccessParent == null) return null
+
+        val firstChildText =
+            staticAccessParent.children
+                .firstOrNull()
+                ?.text ?: ""
+        val psiStaticElement =
+            PsiStaticElement(
+                firstChildText,
+                file,
+            )
+        val javaClazz = psiStaticElement.getRefClazz() ?: return null
+        var parentClass = PsiParentClass(PsiTypesUtil.getClassType(javaClazz))
+
+        val targetElements = getBlockCommentElements(element)
+        if (targetElements.isEmpty()) return null
+
+        val topElm = targetElements.firstOrNull() as? PsiElement ?: return null
+        if (topElm.prevSibling.elementType != SqlTypes.AT_SIGN) return null
+        var index = 1
+        for (staticFieldAccess in targetElements) {
+            if (index >= targetElements.size) {
+                parentClass.findField(elementName)?.let {
+                    PluginLoggerUtil.countLogging(
+                        this::class.java.simpleName,
+                        "ReferenceStaticField",
+                        "Reference",
+                        startTime,
+                    )
+                    return it
+                }
+                parentClass.findMethod(elementName)?.let {
+                    PluginLoggerUtil.countLogging(
+                        this::class.java.simpleName,
+                        "ReferenceStaticMethod",
+                        "Reference",
+                        startTime,
+                    )
+                    return it
+                }
             }
+
+            val newParentType =
+                parentClass.findField(staticFieldAccess.text)?.type
+                    ?: parentClass.findMethod(staticFieldAccess.text)?.returnType
+            if (newParentType == null) return null
+
+            parentClass = PsiParentClass(newParentType)
+            index++
         }
         return null
     }
+
+    private fun getBlockCommentElements(element: PsiElement): List<PsiElement> {
+        val fieldAccessExpr = PsiTreeUtil.getParentOfType(element, SqlElStaticFieldAccessExpr::class.java)
+        val nodeElm =
+            if (fieldAccessExpr != null) {
+                PsiTreeUtil
+                    .getChildrenOfType(
+                        fieldAccessExpr,
+                        SqlElIdExpr::class.java,
+                    )?.filter { it.textOffset <= element.textOffset }
+            } else {
+                listOf(element)
+            }
+        return nodeElm
+            ?.toList()
+            ?.sortedBy { it.textOffset } ?: emptyList()
+    }
 }