Merge pull request #81 from Strum355/detailed-overload-completion

Parameter lists in completion labels

Author: fwcd

package-lock.json

@@ -48,10 +48,13 @@ fun completions(file: CompiledFile, cursor: Int): CompletionList {
 }
 
 private val callPattern = Regex("(.*)\\((\\$\\d+)?\\)")
+private val methodSignature = Regex("""(?:fun|constructor) (?:<(?:[a-zA-Z\?\!\: ]+)(?:, [A-Z])*> )?([a-zA-Z]+\(.*\))""")
 
 private fun completionItem(d: DeclarationDescriptor, surroundingElement: KtElement, file: CompiledFile): CompletionItem {
     val result = d.accept(RenderCompletionItem(), null)
 
+    result.label = methodSignature.find(result.detail)?.groupValues?.get(1) ?: result.label
+
     if (isGetter(d) || isSetter(d)) {
         val name = extractVarName(d)
 

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

@@ -10,15 +10,15 @@ class InstanceMemberTest : SingleFileTestFixture("completions", "InstanceMember.
         val completions = languageServer.textDocumentService.completion(completionParams(file, 3, 15)).get().right!!
         val labels = completions.items.map { it.label }
 
-        assertThat(labels, hasItem("instanceFoo"))
-        assertThat(labels, hasItem("extensionFoo"))
-        assertThat(labels, hasItem("fooVar"))
-        assertThat(labels, not(hasItem("privateInstanceFoo")))
-        assertThat(labels, not(hasItem("getFooVar")))
-        assertThat(labels, not(hasItem("setFooVar")))
+        assertThat(labels, hasItem(startsWith("instanceFoo")))
+        assertThat(labels, hasItem(startsWith("extensionFoo")))
+        assertThat(labels, hasItem(startsWith("fooVar")))
+        assertThat(labels, not(hasItem(startsWith("privateInstanceFoo"))))
+        assertThat(labels, not(hasItem(startsWith("getFooVar"))))
+        assertThat(labels, not(hasItem(startsWith("setFooVar"))))
 
-        assertThat("Reports instanceFoo only once", completions.items.filter { it.label == "instanceFoo" }, hasSize(1))
-        assertThat("Reports extensionFoo only once", completions.items.filter { it.label == "extensionFoo" }, hasSize(1))
+        assertThat("Reports instanceFoo only once", completions.items.filter { it.label.startsWith("instanceFoo") }, hasSize(1))
+        assertThat("Reports extensionFoo only once", completions.items.filter { it.label.startsWith("extensionFoo") }, hasSize(1))
     }
 
     @Test fun `find count extension function`() {
@@ -32,28 +32,28 @@ class InstanceMemberTest : SingleFileTestFixture("completions", "InstanceMember.
         val completions = languageServer.textDocumentService.completion(completionParams(file, 13, 16)).get().right!!
         val labels = completions.items.map { it.label }
 
-        assertThat(labels, hasItem("instanceFoo"))
+        assertThat(labels, hasItem(startsWith("instanceFoo")))
         // assertThat(labels, not(hasItem("extensionFoo"))) Kotlin will probably implement this later
-        assertThat(labels, hasItem("fooVar"))
-        assertThat(labels, not(hasItem("privateInstanceFoo")))
-        assertThat(labels, not(hasItem("getFooVar")))
-        assertThat(labels, not(hasItem("setFooVar")))
+        assertThat(labels, hasItem(startsWith("fooVar")))
+        assertThat(labels, not(hasItem(startsWith("privateInstanceFoo"))))
+        assertThat(labels, not(hasItem(startsWith("getFooVar"))))
+        assertThat(labels, not(hasItem(startsWith("setFooVar"))))
 
-        assertThat(completions.items.filter { it.label == "instanceFoo" }.firstOrNull(), hasProperty("insertText", equalTo("instanceFoo")))
+        assertThat(completions.items.filter { it.label.startsWith("instanceFoo") }.firstOrNull(), hasProperty("insertText", equalTo("instanceFoo")))
     }
 
     @Test fun `complete unqualified function reference`() {
         val completions = languageServer.textDocumentService.completion(completionParams(file, 17, 8)).get().right!!
         val labels = completions.items.map { it.label }
 
-        assertThat(labels, hasItem("findFunctionReference"))
+        assertThat(labels, hasItem(startsWith("findFunctionReference")))
     }
 
     @Test fun `complete a function name within a call`() {
         val completions = languageServer.textDocumentService.completion(completionParams(file, 22, 27)).get().right!!
         val labels = completions.items.map { it.label }
 
-        assertThat(labels, hasItem("findFunctionReference"))
+        assertThat(labels, hasItem(startsWith("findFunctionReference")))
         assertThat(labels, not(hasItem("instanceFoo")))
     }
 }
@@ -73,19 +73,20 @@ class FunctionScopeTest : SingleFileTestFixture("completions", "FunctionScope.kt
         val completions = languageServer.textDocumentService.completion(completionParams(file, 4, 10)).get().right!!
         val labels = completions.items.map { it.label }
 
+        println("ok lol"  + labels.toString())
         assertThat(labels, hasItem("anArgument"))
         assertThat(labels, hasItem("aLocal"))
         assertThat(labels, hasItem("aClassVal"))
-        assertThat(labels, hasItem("aClassFun"))
+        assertThat(labels, hasItem(startsWith("aClassFun")))
         assertThat(labels, hasItem("aCompanionVal"))
-        assertThat(labels, hasItem("aCompanionFun"))
+        assertThat(labels, hasItem(startsWith("aCompanionFun")))
 
         assertThat("Reports anArgument only once", completions.items.filter { it.label == "anArgument" }, hasSize(1))
         assertThat("Reports aLocal only once", completions.items.filter { it.label == "aLocal" }, hasSize(1))
         assertThat("Reports aClassVal only once", completions.items.filter { it.label == "aClassVal" }, hasSize(1))
-        assertThat("Reports aClassFun only once", completions.items.filter { it.label == "aClassFun" }, hasSize(1))
+        assertThat("Reports aClassFun only once", completions.items.filter { it.label.startsWith("aClassFun") }, hasSize(1))
         assertThat("Reports aCompanionVal only once", completions.items.filter { it.label == "aCompanionVal" }, hasSize(1))
-        assertThat("Reports aCompanionFun only once", completions.items.filter { it.label == "aCompanionFun" }, hasSize(1))
+        assertThat("Reports aCompanionFun only once", completions.items.filter { it.label.startsWith("aCompanionFun") }, hasSize(1))
     }
 }
 
@@ -109,7 +110,7 @@ class FillEmptyBodyTest : SingleFileTestFixture("completions", "FillEmptyBody.kt
         val completions = languageServer.textDocumentService.completion(completionParams(file, 3, 20)).get().right!!
         val labels = completions.items.map { it.label }
 
-        assertThat(labels, hasItem("bar"))
+        assertThat(labels, hasItem(startsWith("bar")))
     }
 }
 
@@ -127,7 +128,7 @@ class MiddleOfFunctionTest : SingleFileTestFixture("completions", "MiddleOfFunct
         val completions = languageServer.textDocumentService.completion(completionParams(file, 3, 11)).get().right!!
         val labels = completions.items.map { it.label }
 
-        assertThat(labels, hasItem("subSequence"))
+        assertThat(labels, hasItem(startsWith("subSequence")))
     }
 }
 
@@ -145,28 +146,28 @@ class CompleteStaticsTest : SingleFileTestFixture("completions", "Statics.kt") {
         val completions = languageServer.textDocumentService.completion(completionParams(file, 4, 16)).get().right!!
         val labels = completions.items.map { it.label }
 
-        assertThat(labels, hasItem("isNull"))
+        assertThat(labels, hasItem(startsWith("isNull")))
     }
 
     @Test fun `java static method reference`() {
         val completions = languageServer.textDocumentService.completion(completionParams(file, 7, 17)).get().right!!
         val labels = completions.items.map { it.label }
 
-        assertThat(labels, hasItem("isNull"))
+        assertThat(labels, hasItem(startsWith("isNull")))
     }
 
     @Test fun `object method`() {
         val completions = languageServer.textDocumentService.completion(completionParams(file, 5, 17)).get().right!!
         val labels = completions.items.map { it.label }
 
-        assertThat(labels, hasItem("objectFun"))
+        assertThat(labels, hasItem(startsWith("objectFun")))
     }
 
     @Test fun `companion object method`() {
         val completions = languageServer.textDocumentService.completion(completionParams(file, 6, 16)).get().right!!
         val labels = completions.items.map { it.label }
 
-        assertThat(labels, hasItem("companionFun"))
+        assertThat(labels, hasItem(startsWith("companionFun")))
     }
 }
 
@@ -175,9 +176,9 @@ class VisibilityTest : SingleFileTestFixture("completions", "Visibility.kt") {
         val completions = languageServer.textDocumentService.completion(completionParams(file, 3, 10)).get().right!!
         val labels = completions.items.map { it.label }
 
-        assertThat(labels, hasItems("privateThisFun", "protectedThisFun", "publicThisFun", "privateThisCompanionFun", "protectedThisCompanionFun", "publicThisCompanionFun", "privateTopLevelFun"))
-        assertThat(labels, hasItems("protectedSuperFun", "publicSuperFun", "protectedSuperCompanionFun", "publicSuperCompanionFun"))
-        assertThat(labels, not(hasItems("privateSuperFun", "privateSuperCompanionFun", "publicExtensionFun")))
+        assertThat(labels, hasItems(startsWith("privateThisFun"), startsWith("protectedThisFun"), startsWith("publicThisFun"), startsWith("privateThisCompanionFun"), startsWith("protectedThisCompanionFun"), startsWith("publicThisCompanionFun"), startsWith("privateTopLevelFun")))
+        assertThat(labels, hasItems(startsWith("protectedSuperFun"), startsWith("publicSuperFun"), startsWith("protectedSuperCompanionFun"), startsWith("publicSuperCompanionFun")))
+        assertThat(labels, not(hasItems(startsWith("privateSuperFun"), startsWith("privateSuperCompanionFun"), startsWith("publicExtensionFun"))))
     }
 }
 
@@ -210,7 +211,7 @@ class DoubleDotTest : SingleFileTestFixture("completions", "DoubleDot.kt") {
         val labels = completions.items.map { it.label }
 
         assertThat(labels, not(hasItem("chars")))
-        assertThat(labels, hasItem("anyMatch"))
+        assertThat(labels, hasItem(startsWith("anyMatch")))
     }
 }
 
@@ -219,7 +220,7 @@ class QuestionDotTest : SingleFileTestFixture("completions", "QuestionDot.kt") {
         val completions = languageServer.textDocumentService.completion(completionParams(file, 2, 8)).get().right!!
         val labels = completions.items.map { it.label }
 
-        assertThat(labels, hasItem("chars"))
+        assertThat(labels, hasItem(startsWith("chars")))
     }
 }
 
@@ -244,7 +245,7 @@ class EditCallTest : SingleFileTestFixture("completions", "EditCall.kt") {
         val completions = languageServer.textDocumentService.completion(completionParams(file, 2, 11)).get().right!!
         val labels = completions.items.map { it.label }
 
-        assertThat(labels, hasItem("println"))
-        assertThat(completions.items.filter { it.label == "println" }.firstOrNull(), hasProperty("insertText", equalTo("println")))
+        assertThat(labels, hasItem(startsWith("println")))
+        assertThat(completions.items.filter { it.label.startsWith("println") }.firstOrNull(), hasProperty("insertText", equalTo("println")))
     }
 }