From 1c42e6bee90b7c444e973726e01b137584dfaad5 Mon Sep 17 00:00:00 2001
From: Jason Zaugg <jzaugg@gmail.com>
Date: Wed, 9 Sep 2015 12:02:31 +1000
Subject: More liberal matching in REPL autocompletion

For the SHIFT-impaired: you can just write everything in lowercase,
(whisper-case?) and we'll try to DWYM.

We treat capital letters that you *do* enter as significant, they
can't match a lower case letter in an identifier.

Modelled after IntellIJ's completion.

I still don't fall into this mode if you enter an exact prefix of
a candidate, but we might consider changing that.

```
scala> classOf[String].typ<TAB>
   getAnnotationsByType   getComponentType   getDeclaredAnnotationsByType   getTypeName   getTypeParameters

scala> classOf[String].typN<TAB>
scala> classOf[String].getTypeName
res3: String = java.lang.String

scala> def foo(s: str<TAB>
scala> def foo(s: String
String   StringBuffer   StringBuilder   StringCanBuildFrom   StringContext   StringFormat   StringIndexOutOfBoundsException

scala> def foo(s: string<TAB>
scala> def foo(s: String
String   StringBuffer   StringBuilder   StringCanBuildFrom   StringContext   StringFormat   StringIndexOutOfBoundsException
```
---
 .../scala/tools/nsc/interactive/Global.scala       | 31 +++++++++++++++-------
 .../tools/nsc/interpreter/CompletionTest.scala     |  9 +++++++
 2 files changed, 31 insertions(+), 9 deletions(-)

diff --git a/src/interactive/scala/tools/nsc/interactive/Global.scala b/src/interactive/scala/tools/nsc/interactive/Global.scala
index ae9d816780..6c8719b5eb 100644
--- a/src/interactive/scala/tools/nsc/interactive/Global.scala
+++ b/src/interactive/scala/tools/nsc/interactive/Global.scala
@@ -1189,18 +1189,31 @@ class Global(settings: Settings, _reporter: Reporter, projectName: String = "")
       CamelRegex.findAllIn("X" + s).toList match { case head :: tail => head.drop(1) :: tail; case Nil => Nil }
     }
     def camelMatch(entered: Name): Name => Boolean = {
-      val chunks: List[String] = camelComponents(entered.toString)
+      val enteredS = entered.toString
+      val enteredLowercaseSet = enteredS.toLowerCase().toSet
 
       (candidate: Name) => {
-        val candidateChunks = camelComponents(candidate.toString)
-        val exactCamelMatch =
-          (chunks corresponds candidateChunks.take(chunks.length))((x, y) => y.startsWith(x))
-        def beanCamelMatch = candidateChunks match {
-          case ("get" | "is") :: tail =>
-            (chunks corresponds tail.take(chunks.length))((x, y) => y.toLowerCase.startsWith(x.toLowerCase))
-          case _ => false
+        def candidateChunks = camelComponents(candidate.toString)
+        // Loosely based on IntelliJ's autocompletion: the user can just write everything in
+        // lowercase, as we'll let `isl` match `GenIndexedSeqLike` or `isLovely`.
+        def lenientMatch(entered: String, candidate: List[String], matchCount: Int): Boolean = {
+          candidate match {
+            case Nil => entered.isEmpty && matchCount > 0
+            case head :: tail =>
+              val enteredAlternatives = Set(entered, entered.capitalize)
+              head.inits.filter(_.length <= entered.length).exists(init =>
+                enteredAlternatives.exists(entered =>
+                  lenientMatch(entered.stripPrefix(init), tail, matchCount + (if (init.isEmpty) 0 else 1))
+                )
+              )
+          }
+        }
+        val containsAllEnteredChars = {
+          // Trying to rule out some candidates quickly before the more expensive `lenientMatch`
+          val candidateLowercaseSet = candidate.toString.toLowerCase().toSet
+          enteredLowercaseSet.diff(candidateLowercaseSet).isEmpty
         }
-        exactCamelMatch || beanCamelMatch
+        containsAllEnteredChars && lenientMatch(enteredS, candidateChunks, 0)
       }
     }
   }
diff --git a/test/junit/scala/tools/nsc/interpreter/CompletionTest.scala b/test/junit/scala/tools/nsc/interpreter/CompletionTest.scala
index a55a3c66c0..534d5ddc3a 100644
--- a/test/junit/scala/tools/nsc/interpreter/CompletionTest.scala
+++ b/test/junit/scala/tools/nsc/interpreter/CompletionTest.scala
@@ -62,6 +62,15 @@ class CompletionTest {
     checkExact(completer, "object O { class AbstractMetaFactoryFactory }; new O.AMFF")("AbstractMetaFactoryFactory")
   }
 
+  @Test
+  def lenientCamelCompletions(): Unit = {
+    val intp = newIMain()
+    val completer = new PresentationCompilerCompleter(intp)
+    checkExact(completer, "object O { def theCatSatOnTheMat = 1 }; import O._; tcso")("theCatSatOnTheMat")
+    checkExact(completer, "object O { def theCatSatOnTheMat = 1 }; import O._; sotm")("theCatSatOnTheMat")
+    checkExact(completer, "object O { def theCatSatOnTheMat = 1 }; import O._; TCSOTM")()
+  }
+
   @Test
   def previousLineCompletions(): Unit = {
     val intp = newIMain()
-- 
cgit v1.2.3