Merge pull request #226 from domaframework/fix/code-completion-suggestions-after-static-property-accesses

Fix code completion for static field access

Author: xterao

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

@@ -19,12 +19,16 @@ import com.intellij.patterns.PatternCondition
 import com.intellij.patterns.PlatformPatterns
 import com.intellij.patterns.PsiElementPattern
 import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiWhiteSpace
 import com.intellij.psi.TokenType
+import com.intellij.psi.tree.IElementType
 import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.psi.util.elementType
 import com.intellij.psi.util.prevLeaf
 import com.intellij.psi.util.prevLeafs
 import com.intellij.util.ProcessingContext
+import org.domaframework.doma.intellij.common.sql.directive.DirectiveCompletion
+import org.domaframework.doma.intellij.psi.SqlCustomElCommentExpr
 import org.domaframework.doma.intellij.psi.SqlElClass
 import org.domaframework.doma.intellij.psi.SqlElIdExpr
 import org.domaframework.doma.intellij.psi.SqlTypes
@@ -43,7 +47,28 @@ object PsiPatternUtil {
                 override fun accepts(
                     element: PsiElement,
                     context: ProcessingContext?,
-                ): Boolean = PsiTreeUtil.getParentOfType(element, parentClass, true) != null
+                ): Boolean {
+                    val inComment = PsiTreeUtil.getParentOfType(element, parentClass, true) != null
+                    if (inComment) return true
+
+                    // Even incomplete elements during input are analyzed as strings and included in the code completion process within block comments.
+                    var prevElement = PsiTreeUtil.prevLeaf(element, true)
+                    while (prevElement != null &&
+                        !(
+                            prevElement.nextSibling is SqlCustomElCommentExpr &&
+                                !prevElement.nextSibling.text.endsWith("*/")
+                        )
+                    ) {
+                        prevElement = PsiTreeUtil.prevLeaf(prevElement, true)
+                    }
+
+                    var endBlock = PsiTreeUtil.nextLeaf(element, true)
+                    while (endBlock != null && endBlock.elementType != SqlTypes.BLOCK_COMMENT_END) {
+                        endBlock = PsiTreeUtil.nextLeaf(endBlock, true)
+                    }
+
+                    return prevElement != null && endBlock != null
+                }
             },
         )
 
@@ -55,7 +80,7 @@ object PsiPatternUtil {
                     context: ProcessingContext?,
                 ): Boolean {
                     val bindText = element.prevLeaf()?.text ?: ""
-                    val directiveSymbol = listOf("%", "@", "^", "#")
+                    val directiveSymbol = DirectiveCompletion.directiveSymbols
                     return directiveSymbol.any {
                         bindText.startsWith(it) ||
                             (element.elementType == SqlTypes.EL_IDENTIFIER && element.prevLeaf()?.text == it) ||
@@ -104,7 +129,7 @@ object PsiPatternUtil {
 
     /**
      * Get the string to search from the cursor position to the start of a block comment or a blank space
-     * @return search Keyword
+     * @return The string up to the specified character
      */
     fun getBindSearchWord(
         originalFile: PsiElement,
@@ -126,4 +151,21 @@ object PsiPatternUtil {
                 .substringAfter(symbol)
         return prefix
     }
+
+    fun getBindSearchWord(
+        element: PsiElement,
+        targetType: IElementType?,
+    ): MutableList<PsiElement> {
+        var prevElement = PsiTreeUtil.prevLeaf(element, true)
+        var prevElements = mutableListOf<PsiElement>()
+        while (prevElement != null &&
+            prevElement !is PsiWhiteSpace &&
+            prevElement.elementType != targetType &&
+            prevElement.elementType != SqlTypes.BLOCK_COMMENT_START
+        ) {
+            prevElements.add(prevElement)
+            prevElement = PsiTreeUtil.prevLeaf(prevElement, true)
+        }
+        return prevElements
+    }
 }

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

@@ -19,6 +19,7 @@ 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.common.util.StringUtil
 import org.domaframework.doma.intellij.extension.getJavaClazz
 import org.domaframework.doma.intellij.psi.SqlElExpr
 
@@ -32,10 +33,7 @@ class PsiStaticElement(
     private var fqdn = elExprList?.joinToString(".") { e -> e.text } ?: ""
 
     constructor(elExprNames: String, file: PsiFile) : this(null, file) {
-        fqdn =
-            elExprNames
-                .substringAfter("@")
-                .substringBefore("@")
+        fqdn = StringUtil.getSqlElClassText(elExprNames)
     }
 
     fun getRefClazz(): PsiClass? {

src/main/kotlin/org/domaframework/doma/intellij/common/sql/CleanElementText.kt

@@ -15,15 +15,16 @@
  */
 package org.domaframework.doma.intellij.common.sql
 
+import org.domaframework.doma.intellij.common.util.StringUtil
+
 /**
  * Exclude extra strings and block symbols added by IntelliJ operations a
  * nd format them into necessary elements
  */
 fun cleanString(str: String): String {
     val intelliKIdeaRuleZzz = "IntellijIdeaRulezzz"
-    return str
-        .substringAfter("/*")
-        .substringBefore("*/")
+    return StringUtil
+        .replaceBlockCommentStartEnd(str)
         .replace(intelliKIdeaRuleZzz, "")
         // TODO: Temporary support when using operators.
         //  Remove the "== a" element because it is attached to the end.

src/main/kotlin/org/domaframework/doma/intellij/common/sql/directive/DirectiveCompletion.kt

@@ -26,6 +26,16 @@ class DirectiveCompletion(
     private val caretNextText: String,
     private val result: CompletionResultSet,
 ) {
+    companion object {
+        val directiveSymbols =
+            listOf(
+                "%",
+                "#",
+                "^",
+                "@",
+            )
+    }
+
     fun directiveHandle(symbol: String): Boolean {
         return when (symbol) {
             "%" ->

src/main/kotlin/org/domaframework/doma/intellij/common/sql/directive/StaticDirectiveHandler.kt

@@ -18,8 +18,10 @@ package org.domaframework.doma.intellij.common.sql.directive
 import com.intellij.codeInsight.completion.CompletionResultSet
 import com.intellij.openapi.module.Module
 import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiWhiteSpace
 import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.psi.util.elementType
+import org.domaframework.doma.intellij.common.psi.PsiPatternUtil
 import org.domaframework.doma.intellij.common.sql.directive.collector.FunctionCallCollector
 import org.domaframework.doma.intellij.common.sql.directive.collector.StaticClassPackageCollector
 import org.domaframework.doma.intellij.common.sql.directive.collector.StaticPropertyCollector
@@ -38,14 +40,12 @@ class StaticDirectiveHandler(
     override fun directiveHandle(): Boolean {
         var handleResult = false
 
-        if (isNextStaticFieldAccess(element)) {
+        if (isStaticFieldAccessTopElement(element)) {
             handleResult = staticDirectiveHandler(element, result)
         }
         if (handleResult) return true
 
-        if (PsiTreeUtil.nextLeaf(element)?.elementType == SqlTypes.AT_SIGN ||
-            element.elementType == SqlTypes.AT_SIGN
-        ) {
+        if (isSqlElClassCompletion()) {
             val module = element.module ?: return false
             handleResult =
                 collectionModulePackages(
@@ -55,32 +55,95 @@ class StaticDirectiveHandler(
         }
         if (handleResult) return true
 
-        if (PsiTreeUtil.prevLeaf(element)?.elementType == SqlTypes.AT_SIGN) {
+        if (PsiTreeUtil.prevLeaf(element, true)?.elementType == SqlTypes.AT_SIGN) {
             // Built-in function completion
             handleResult = builtInDirectiveHandler(element, result)
         }
         return handleResult
     }
 
-    private fun isNextStaticFieldAccess(element: PsiElement): Boolean {
-        val prev = PsiTreeUtil.prevLeaf(element)
-        return element.prevSibling is SqlElStaticFieldAccessExpr ||
+    /**
+     * Determines whether code completion is needed for [SqlElClass] elements.
+     */
+    private fun isSqlElClassCompletion(): Boolean {
+        if (element.elementType == SqlTypes.AT_SIGN &&
+            PsiTreeUtil.prevLeaf(element)?.elementType == SqlTypes.AT_SIGN
+        ) {
+            return true
+        }
+
+        val elClassPattern = "^([a-zA-Z]*(\\.)+)*$"
+        val regex = Regex(elClassPattern)
+        val prevElements = PsiPatternUtil.getBindSearchWord(element, SqlTypes.AT_SIGN)
+        val topAtSign = PsiTreeUtil.prevLeaf(prevElements.lastOrNull() ?: element, true)
+        val prevWords = prevElements.reversed().joinToString("") { it.text }
+
+        // If the cursor is in the middle of [SqlElClass],
+        // search for the following @ and ensure that code completion is within [SqlElClass].
+        if (element.elementType != SqlTypes.AT_SIGN) {
+            var nextElement = PsiTreeUtil.nextLeaf(element, true)
+            while (nextElement != null &&
+                nextElement !is PsiWhiteSpace &&
+                nextElement.elementType != SqlTypes.BLOCK_COMMENT_END &&
+                nextElement.elementType != SqlTypes.AT_SIGN
+            ) {
+                nextElement = PsiTreeUtil.nextLeaf(nextElement, true)
+            }
+            val lastAtSign = PsiTreeUtil.nextLeaf(nextElement ?: element, true)
+            if (regex.matches(prevWords) &&
+                (
+                    lastAtSign == null ||
+                        nextElement.elementType != SqlTypes.AT_SIGN ||
+                        lastAtSign.elementType == SqlTypes.BLOCK_COMMENT_END
+                )
+            ) {
+                return false
+            }
+        }
+
+        // Check if there is a partially entered class package name ahead and ensure that input is in [SqlElClass].
+        if (prevElements.isEmpty()) return false
+        return (
+            topAtSign?.elementType == SqlTypes.AT_SIGN &&
+                PsiTreeUtil.prevLeaf(topAtSign, true)?.elementType != SqlTypes.EL_IDENTIFIER &&
+                regex.matches(prevWords)
+        )
+    }
+
+    /**
+     * Code completion for static properties after [SqlElClass].
+     */
+    private fun isStaticFieldAccessTopElement(element: PsiElement): Boolean {
+        val prev = PsiTreeUtil.prevLeaf(element, true)
+        val staticFieldAccess =
+            PsiTreeUtil.getParentOfType(prev, SqlElStaticFieldAccessExpr::class.java)
+        val sqlElClassWords = PsiPatternUtil.getBindSearchWord(element.containingFile, element, " ")
+        return (
+            staticFieldAccess != null && staticFieldAccess.elIdExprList.isEmpty()
+        ) ||
             (
                 prev?.elementType == SqlTypes.AT_SIGN &&
                     prev.parent is SqlElStaticFieldAccessExpr
+            ) ||
+            (
+                sqlElClassWords.startsWith("@") &&
+                    sqlElClassWords.endsWith("@")
             )
     }
 
     private fun staticDirectiveHandler(
         element: PsiElement,
         result: CompletionResultSet,
     ): Boolean {
+        val prev = PsiTreeUtil.prevLeaf(element, true)
         val clazzRef =
             PsiTreeUtil
-                .getChildOfType(element.prevSibling, SqlElClass::class.java)
+                .getChildOfType(prev, SqlElClass::class.java)
                 ?: PsiTreeUtil.getChildOfType(PsiTreeUtil.prevLeaf(element)?.parent, SqlElClass::class.java)
-        val fqdn =
-            PsiTreeUtil.getChildrenOfTypeAsList(clazzRef, PsiElement::class.java).joinToString("") { it.text }
+
+        val sqlElClassWords = PsiPatternUtil.getBindSearchWord(element.containingFile, element, " ")
+        val sqlElClassName = PsiTreeUtil.getChildrenOfTypeAsList(clazzRef, PsiElement::class.java).joinToString("") { it.text }
+        val fqdn = if (sqlElClassName.isNotEmpty()) sqlElClassName else sqlElClassWords.replace("@", "")
 
         val collector = StaticPropertyCollector(element, caretNextText, bindText)
         val candidates = collector.collectCompletionSuggest(fqdn) ?: return false

src/main/kotlin/org/domaframework/doma/intellij/common/util/ForDirectiveUtil.kt

@@ -67,6 +67,9 @@ class ForDirectiveUtil {
         private val cachedForDirectiveBlocks: MutableMap<PsiElement, CachedValue<List<BlockToken>>> =
             mutableMapOf()
 
+        const val HAS_NEXT_PREFIX = "_has_next"
+        const val INDEX_PREFIX = "_index"
+
         /**
          *  Get the parent for directive list to which this directive belongs
          * @param targetElement Element to search for definer
@@ -162,7 +165,7 @@ class ForDirectiveUtil {
             skipSelf: Boolean = true,
             forDirectives: List<BlockToken> = getForDirectiveBlocks(targetElement, skipSelf),
         ): PsiElement? {
-            val searchText = targetElement.text.replace("_has_next", "").replace("_index", "")
+            val searchText = targetElement.text.replace(HAS_NEXT_PREFIX, "").replace(INDEX_PREFIX, "")
             return forDirectives.firstOrNull { it.item.text == searchText }?.item
         }
 
@@ -507,9 +510,9 @@ class ForDirectiveUtil {
             }
 
         fun resolveForDirectiveItemClassTypeBySuffixElement(searchName: String): PsiType? =
-            if (searchName.endsWith("_has_next")) {
+            if (searchName.endsWith(HAS_NEXT_PREFIX)) {
                 PsiTypes.booleanType()
-            } else if (searchName.endsWith("_index")) {
+            } else if (searchName.endsWith(INDEX_PREFIX)) {
                 PsiTypes.intType()
             } else {
                 null

src/main/kotlin/org/domaframework/doma/intellij/common/util/StringUtil.kt

@@ -0,0 +1,25 @@
+/*
+ * Copyright Doma Tools Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.domaframework.doma.intellij.common.util
+
+object StringUtil {
+    fun getSqlElClassText(text: String): String =
+        text
+            .substringAfter("@")
+            .substringBefore("@")
+
+    fun replaceBlockCommentStartEnd(text: String): String = text.substringAfter("/*").substringBefore("*/")
+}