Initial fuzzy search

Author: rochala

compiler/src/dotty/tools/dotc/interactive/Completion.scala

@@ -71,10 +71,11 @@ object Completion:
     mode: Mode,
     rawPrefix: String,
     tpdPath: List[tpd.Tree],
-    untpdPath: List[untpd.Tree]
+    untpdPath: List[untpd.Tree],
+    prefixFilter: Option[Name => Boolean] = None
   )(using Context): CompletionMap =
     val adjustedPath = typeCheckExtensionConstructPath(untpdPath, tpdPath, pos)
-    computeCompletions(pos, mode, rawPrefix, adjustedPath)
+    computeCompletions(pos, mode, rawPrefix, adjustedPath, prefixFilter)
 
   /**
    * Inspect `path` to determine what kinds of symbols should be considered.
@@ -198,11 +199,12 @@ object Completion:
     .flatten.getOrElse(tpdPath)
 
   private def computeCompletions(
-    pos: SourcePosition, mode: Mode, rawPrefix: String, adjustedPath: List[tpd.Tree]
+    pos: SourcePosition, mode: Mode, rawPrefix: String, adjustedPath: List[tpd.Tree], prefixFilter: Option[Name => Boolean]
   )(using Context): CompletionMap =
     val hasBackTick = rawPrefix.headOption.contains('`')
     val prefix = if hasBackTick then rawPrefix.drop(1) else rawPrefix
-    val completer = new Completer(mode, prefix, pos)
+    val prefixFilter0 = prefixFilter.getOrElse(_.startsWith(prefix))
+    val completer = new Completer(mode, prefix, pos, prefixFilter0)
 
     val result = adjustedPath match
       // Ignore synthetic select from `This` because in code it was `Ident`
@@ -296,7 +298,7 @@ object Completion:
    *  For the results of all `xyzCompletions` methods term names and type names are always treated as different keys in the same map
    *  and they never conflict with each other.
    */
-  class Completer(val mode: Mode, val prefix: String, pos: SourcePosition):
+  class Completer(val mode: Mode, val prefix: String, pos: SourcePosition, prefixFilter: Name => Boolean):
     /** Completions for terms and types that are currently in scope:
      *  the members of the current class, local definitions and the symbols that have been imported,
      *  recursively adding completions from outer scopes.
@@ -503,10 +505,10 @@ object Completion:
       // There are four possible ways for an extension method to be applicable
 
       // 1. The extension method is visible under a simple name, by being defined or inherited or imported in a scope enclosing the reference.
-      val termCompleter = new Completer(Mode.Term, prefix, pos)
-      val extMethodsInScope = termCompleter.scopeCompletions.toList.flatMap:
-        case (name, denots) => denots.collect:
-          case d: SymDenotation if d.isTerm && d.termRef.symbol.is(Extension) => (d.termRef, name.asTermName)
+      val termCompleter = new Completer(Mode.Term, prefix, pos, _.startsWith(prefix))
+      val extMethodsInScope = termCompleter.scopeCompletions.toList.flatMap {
+        case (name, denots) => denots.collect { case d: SymDenotation if d.isTerm => (d.termRef, name.asTermName) }
+      }
 
       // 2. The extension method is a member of some given instance that is visible at the point of the reference.
       val givensInScope = ctx.implicits.eligible(defn.AnyType).map(_.implicitRef.underlyingRef)
@@ -545,7 +547,7 @@ object Completion:
       val sym = denot.symbol
 
 
-      nameInScope.startsWith(prefix) &&
+      prefixFilter(nameInScope) &&
       sym.exists &&
       completionsFilter(NoType, nameInScope) &&
       !sym.isAbsent() &&

presentation-compiler/src/main/dotty/tools/pc/completions/Completions.scala

@@ -110,24 +110,26 @@ class Completions(
     val (all, result) =
       if exclusive then (advanced, SymbolSearch.Result.COMPLETE)
       else
-        val keywords =
-          KeywordsCompletions.contribute(path, completionPos, comments)
+        val keywords = KeywordsCompletions.contribute(adjustedPath, completionPos, comments)
         val allAdvanced = advanced ++ keywords
+        val fuzzyMatcher: Name => Boolean = name =>
+          Fuzzy.matchesSubCharacters(completionPos.query, name.toString)
+
         path match
           // should not show completions for toplevel
           case Nil | (_: PackageDef) :: _ if completionPos.originalCursorPosition.source.file.extension != "sc" =>
             (allAdvanced, SymbolSearch.Result.COMPLETE)
           case Select(qual, _) :: _ if qual.typeOpt.isErroneous =>
             (allAdvanced, SymbolSearch.Result.COMPLETE)
           case Select(qual, _) :: _ =>
-            val compilerCompletions = Completion.rawCompletions(completionPos.originalCursorPosition, completionMode, completionPos.query, path, adjustedPath)
+            val compilerCompletions = Completion.rawCompletions(completionPos.originalCursorPosition, completionMode, completionPos.query, path, adjustedPath, Some(fuzzyMatcher))
             val (compiler, result) = compilerCompletions
               .toList
               .flatMap(toCompletionValues)
               .filterInteresting(qual.typeOpt.widenDealias)
             (allAdvanced ++ compiler, result)
           case _ =>
-            val compilerCompletions = Completion.rawCompletions(completionPos.originalCursorPosition, completionMode, completionPos.query, path, adjustedPath)
+            val compilerCompletions = Completion.rawCompletions(completionPos.originalCursorPosition, completionMode, completionPos.query, path, adjustedPath, Some(fuzzyMatcher))
             val (compiler, result) = compilerCompletions
               .toList
               .flatMap(toCompletionValues)

presentation-compiler/src/main/dotty/tools/pc/completions/KeywordsCompletions.scala

@@ -5,7 +5,7 @@ import scala.meta.internal.pc.Keyword
 
 import dotty.tools.dotc.ast.NavigateAST
 import dotty.tools.dotc.ast.Positioned
-import dotty.tools.dotc.ast.tpd.*
+import dotty.tools.dotc.ast.untpd.*
 import dotty.tools.dotc.ast.untpd
 import dotty.tools.dotc.ast.untpd.UntypedTreeTraverser
 import dotty.tools.dotc.core.Comments

presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionKeywordSuite.scala

@@ -718,8 +718,8 @@ class CompletionKeywordSuite extends BaseCompletionSuite:
         |trait Bar {}
         |class Baz(b: Int) {}
         |
-        |class Foo(x: Int) extends Bar with Baz(1) der@@
-                  """.stripMargin,
+        |class Foo(x: Int) extends Bar with Baz(1) @@
+        """.stripMargin,
       """|derives
          |""".stripMargin
     )
@@ -737,3 +737,63 @@ class CompletionKeywordSuite extends BaseCompletionSuite:
         """.stripMargin,
       ""
     )
+
+  @Test def `only-keywords` =
+    check(
+      """
+        |package foo
+        |
+        |object Main {
+        |  class Baz(x: Int) @@
+        |}
+        """.stripMargin,
+      ""
+    )
+
+  @Test def `only-keywords-1` =
+    check(
+      """
+        |package foo
+        |
+        |object Main {
+        |  class Baz(x: Int)
+        |  p@@
+        |}
+        """.stripMargin,
+      ""
+    )
+
+  @Test def `only-keywords-2` =
+    check(
+      """
+        |package foo
+        |
+        |class Baz(x: Int) @@
+        """.stripMargin,
+      ""
+    )
+
+  @Test def `def-after-extension` =
+    check(
+      """
+        |object Main {
+        |  extension (x: Int) @@
+        |}
+        """.stripMargin,
+      """|derives
+         |private
+         |""".stripMargin
+    )
+
+  @Test def `def-after-extension-newline` =
+    check(
+      """
+        |object Main {
+        |  extension (x: Int)
+        |    @@
+        |}
+        """.stripMargin,
+      """|derives
+         |private
+         |""".stripMargin
+    )