COMP: don't show popup for let binding starting with a lowercase char

Author: vlad20012

src/main/kotlin/org/rust/lang/core/completion/RsCompletionConfidence.kt

@@ -0,0 +1,34 @@
+/*
+ * Use of this source code is governed by the MIT license that can be
+ * found in the LICENSE file.
+ */
+
+package org.rust.lang.core.completion
+
+import com.intellij.codeInsight.completion.CompletionConfidence
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiFile
+import com.intellij.util.ThreeState
+import org.rust.lang.core.psi.RsElementTypes.IDENTIFIER
+import org.rust.lang.core.psi.RsLetDecl
+import org.rust.lang.core.psi.RsPatBinding
+import org.rust.lang.core.psi.ext.elementType
+import org.rust.lang.core.psi.ext.topLevelPattern
+
+class RsCompletionConfidence : CompletionConfidence() {
+    override fun shouldSkipAutopopup(contextElement: PsiElement, psiFile: PsiFile, offset: Int): ThreeState {
+        // Don't show completion popup when typing a `let binding` identifier starting with a lowercase letter.
+        // If the identifier is uppercase, the user probably wants to type a destructuring pattern
+        // (`let Foo { ... }`), so we show the completion popup in this case
+        if (contextElement.elementType == IDENTIFIER) {
+            val identText = contextElement.node.chars
+            if (identText.firstOrNull()?.isLowerCase() == true && !"mu".startsWith(identText)) {
+                val parent = contextElement.parent
+                if (parent is RsPatBinding && parent.topLevelPattern.parent is RsLetDecl) {
+                    return ThreeState.YES
+                }
+            }
+        }
+        return ThreeState.UNSURE
+    }
+}

src/main/resources/META-INF/rust-core.xml

@@ -241,6 +241,9 @@
 
         <codeCompletionConfigurable instance="org.rust.ide.settings.RsCodeCompletionConfigurable"/>
 
+        <completion.confidence language="Rust"
+                               implementationClass="org.rust.lang.core.completion.RsCompletionConfidence"/>
+
         <completion.contributor language="Rust"
                                 implementationClass="org.rust.lang.core.completion.RsKeywordCompletionContributor"
                                 id="RsKeywordCompletionContributor"

src/test/kotlin/org/rust/lang/core/completion/RsCompletionAutoPopupTest.kt

@@ -66,6 +66,76 @@ class RsCompletionAutoPopupTest : RsCompletionTestBase() {
         }
     """, "|")
 
+    fun `test popup is not shown when typing lowercase let binding`() = checkPopupIsNotShownAfterTyping("""
+        struct a1 { f: i32 }
+        const a2: i32 = 1;
+        fn main() {
+            let /*caret*/
+        }
+    """, "a")
+
+    fun `test popup is not shown when typing nested lowercase let binding`() = checkPopupIsNotShownAfterTyping("""
+        struct a1 { f: i32 }
+        const a2: i32 = 1;
+        fn main() {
+            let (a, /*caret*/)
+        }
+    """, "a")
+
+    fun `test popup is shown when typing uppercase let binding`() = checkPopupIsShownAfterTyping("""
+        struct A1 { f: i32 }
+        const A2: i32 = 1;
+        fn main() {
+            let /*caret*/
+        }
+    """, "A")
+
+    fun `test popup is shown when typing if let binding`() = checkPopupIsShownAfterTyping("""
+        struct a1 { f: i32 }
+        const a2: i32 = 1;
+        fn main() {
+            if let /*caret*/
+        }
+    """, "a")
+
+    fun `test popup is shown when typing while let binding`() = checkPopupIsShownAfterTyping("""
+        struct a1 { f: i32 }
+        const a2: i32 = 1;
+        fn main() {
+            while let /*caret*/
+        }
+    """, "a")
+
+    fun `test popup is shown when typing binding in match arm`() = checkPopupIsShownAfterTyping("""
+        struct a1 { f: i32 }
+        const a2: i32 = 1;
+        fn main() {
+            match 1 {
+                /*caret*/
+            }
+        }
+    """, "a")
+
+    fun `test popup is shown when typing let mut 1`() = checkPopupIsShownAfterTyping("""
+        fn main() {
+            let /*caret*/
+        }
+    """, "m")
+
+    fun `test popup is shown when typing let mut 2`() = checkPopupIsShownAfterTyping("""
+        fn main() {
+            let m/*caret*/
+        }
+    """, "u")
+
+    fun `test popup is not shown when typing lowercase let mut binding`() = checkPopupIsNotShownAfterTyping("""
+        struct a1 { f: i32 }
+        const a2: i32 = 1;
+        fn main() {
+            let mut /*caret*/
+        }
+    """, "a")
+
     override fun setUp() {
         super.setUp()
         tester = CompletionAutoPopupTester(myFixture)