add infix function completions

Author: elamc-2

server/src/main/kotlin/org/javacs/kt/completion/Completions.kt

@@ -249,6 +249,8 @@ private fun completableElement(file: CompiledFile, cursor: Int): KtElement? {
             ?: el.parent?.parent as? KtQualifiedExpression
             // ?
             ?: el as? KtNameReferenceExpression
+            // x ? y (infix)
+            ?: el.parent as? KtBinaryExpression
 }
 
 private fun elementCompletions(file: CompiledFile, cursor: Int, surroundingElement: KtElement): Sequence<DeclarationDescriptor> {
@@ -319,13 +321,27 @@ private fun elementCompletions(file: CompiledFile, cursor: Int, surroundingEleme
             val scope = file.scopeAtPoint(surroundingElement.startOffset) ?: return noResult("No scope at ${file.describePosition(cursor)}", emptySequence())
             identifiers(scope)
         }
+        // x ? y (infix)
+        is KtBinaryExpression -> {
+            if (surroundingElement.operationToken == KtTokens.IDENTIFIER) {
+                completeMembers(file, cursor, surroundingElement.left!!)
+            } else emptySequence()
+        }
         else -> {
             LOG.info("{} {} didn't look like a type, a member, or an identifier", surroundingElement::class.simpleName, surroundingElement.text)
             emptySequence()
         }
     }
 }
 
+private fun receiverDescriptors(exp: KtExpression, vararg descriptors: Sequence<DeclarationDescriptor>): Sequence<DeclarationDescriptor> {
+    val seq = sequenceOf(*descriptors).flatten()
+    if (exp.parent !is KtBinaryExpression) return seq
+
+    // filter if infix call
+    return seq.filter { declarationIsInfix(it) }
+}
+
 private fun completeMembers(file: CompiledFile, cursor: Int, receiverExpr: KtExpression, unwrapNullable: Boolean = false): Sequence<DeclarationDescriptor> {
     // thingWithType.?
     var descriptors = emptySequence<DeclarationDescriptor>()
@@ -341,7 +357,7 @@ private fun completeMembers(file: CompiledFile, cursor: Int, receiverExpr: KtExp
             LOG.debug("Completing members of instance '{}'", receiverType)
             val members = receiverType.memberScope.getContributedDescriptors().asSequence()
             val extensions = extensionFunctions(lexicalScope).filter { isExtensionFor(receiverType, it) }
-            descriptors = members + extensions
+            descriptors = receiverDescriptors(receiverExpr, members, extensions)
 
             if (!isCompanionOfEnum(receiverType) && !isCompanionOfSealed(receiverType)) {
                 return descriptors
@@ -370,6 +386,11 @@ private fun ClassDescriptor.getDescriptors(): Sequence<DeclarationDescriptor> {
 
 }
 
+private fun declarationIsInfix(declaration: DeclarationDescriptor): Boolean {
+    val functionDescriptor = declaration as? FunctionDescriptor ?: return false
+    return functionDescriptor.isInfix
+}
+
 private fun isCompanionOfEnum(kotlinType: KotlinType): Boolean {
     val classDescriptor = TypeUtils.getClassDescriptor(kotlinType)
     val isCompanion = DescriptorUtils.isCompanionObject(classDescriptor)

server/src/test/kotlin/org/javacs/kt/CompletionsTest.kt

@@ -65,6 +65,32 @@ class InstanceMemberTest : SingleFileTestFixture("completions", "InstanceMember.
     }
 }
 
+class InfixMethodTest : SingleFileTestFixture("completions", "InfixFunctions.kt") {
+    @Test fun `complete member function`() {
+        val completions = languageServer.textDocumentService.completion(completionParams(file, 10, 11)).get().right!!
+        val labels = completions.items.map { it.label }
+
+        assertThat(labels, hasItem(startsWith("cmpB")))
+        assertThat(labels, not(hasItem(startsWith("cmpA"))))
+    }
+
+    @Test fun `includes completion for stdlib`() {
+        val completions = languageServer.textDocumentService.completion(completionParams(file, 15, 9)).get().right!!
+        val labels = completions.items.map { it.label }
+
+        assertThat(labels, hasSize(2))
+        assertThat(labels, hasItem(startsWith("and")))
+        assertThat(labels, hasItem("andTo"))
+    }
+
+    @Test fun `complete extension function`() {
+        val completions = languageServer.textDocumentService.completion(completionParams(file, 19, 9)).get().right!!
+        val labels = completions.items.map { it.label }
+
+        assertThat(labels, hasItem("funcA"))
+    }
+}
+
 class InstanceMembersJava : SingleFileTestFixture("completions", "InstanceMembersJava.kt") {
     @Test fun `convert getFileName to fileName`() {
         val completions = languageServer.textDocumentService.completion(completionParams(file, 4, 14)).get().right!!

server/src/test/resources/completions/InfixFunctions.kt

@@ -0,0 +1,21 @@
+class Q {
+    fun cmpA(): Double = 1.0
+    infix fun cmpB(x: Int): Int { return 1 }
+}
+
+infix fun Int.funcA(x: Int): Boolean = x == this
+infix fun Int.andTo(v: Int) = v
+
+private fun memberFunc() {
+    Q() cm
+}
+
+private fun stdlibFunc() {
+    val v = 1
+    v and
+}
+
+private fun extensionFunc() {
+    2 fu 3
+}
+