fix: ensure you still get completion when using backticks

This commit addresses the situation where you are trying to use a
backtick when it's not needed. For example if you have:

```scala
object Foo:
  case `bar`
  case foo

Foo.`b
```

You still expect to get a completion bar being backticked. This also
ensure that if you try ``Foo.`fo`` you also still get a completion.

Author: ckipp01

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

@@ -15,7 +15,6 @@ import dotty.tools.dotc.core.StdNames.nme
 import dotty.tools.dotc.core.SymDenotations.SymDenotation
 import dotty.tools.dotc.core.TypeError
 import dotty.tools.dotc.core.Types.{ExprType, MethodOrPoly, NameFilter, NoType, TermRef, Type}
-import dotty.tools.dotc.parsing.Scanners
 import dotty.tools.dotc.parsing.Tokens
 import dotty.tools.dotc.util.Chars
 import dotty.tools.dotc.util.SourcePosition
@@ -118,6 +117,7 @@ object Completion {
   private def computeCompletions(pos: SourcePosition, path: List[Tree])(using Context): (Int, List[Completion]) = {
     val mode = completionMode(path, pos)
     val rawPrefix = completionPrefix(path, pos)
+
     val hasBackTick = rawPrefix.headOption.contains('`')
     val prefix = if hasBackTick then rawPrefix.drop(1) else rawPrefix
 
@@ -135,7 +135,8 @@ object Completion {
       }
 
     val describedCompletions = describeCompletions(completions)
-    val backtickedCompletions = describedCompletions.map(backtickCompletions)
+    val backtickedCompletions =
+      describedCompletions.map(completion => backtickCompletions(completion, hasBackTick))
 
     val offset = completionOffset(path)
 
@@ -147,14 +148,14 @@ object Completion {
     (offset, backtickedCompletions)
   }
 
-  def backtickCompletions(completion: Completion) =
-    if needsBacktick(completion.label) then
+  def backtickCompletions(completion: Completion, hasBackTick: Boolean) =
+    if hasBackTick || needsBacktick(completion.label) then
       completion.copy(label = s"`${completion.label}`")
     else
       completion
 
   // This borrows from Metals, which itself borrows from Ammonite. This uses
-  // the same apprach, but some of the utils that already exist in Dotty.
+  // the same approach, but some of the utils that already exist in Dotty.
   // https://github.com/scalameta/metals/blob/main/mtags/src/main/scala/scala/meta/internal/mtags/KeywordWrapper.scala
   // https://github.com/com-lihaoyi/Ammonite/blob/73a874173cd337f953a3edc9fb8cb96556638fdd/amm/util/src/main/scala/ammonite/util/Model.scala
   private def needsBacktick(s: String) =
@@ -429,6 +430,7 @@ object Completion {
     private def include(denot: SingleDenotation, nameInScope: Name)(using Context): Boolean =
       val sym = denot.symbol
 
+
       nameInScope.startsWith(prefix) &&
       sym.exists &&
       completionsFilter(NoType, nameInScope) &&

compiler/src/dotty/tools/repl/ReplDriver.scala

@@ -35,8 +35,6 @@ import org.jline.reader._
 import scala.annotation.tailrec
 import scala.collection.JavaConverters._
 import scala.util.Using
-import dotty.tools.dotc.util.Chars
-import dotty.tools.dotc.parsing.Tokens
 
 /** The state of the REPL contains necessary bindings instead of having to have
  *  mutation

language-server/test/dotty/tools/languageserver/CompletionTest.scala

@@ -1078,4 +1078,47 @@ class CompletionTest {
            |  val x = Bar.`back${m1}"""
              .withSource.completion(m1, expected)
   }
+
+  @Test def backticksSpace: Unit = {
+    val expected = Set(
+      ("`has space`", Field, "Foo.Bar"),
+    )
+    code"""object Foo:
+           |  enum Bar:
+           |    case `has space`
+           |  
+           |  val x = Bar.`has s${m1}"""
+             .withSource.completion(m1, expected)
+  }
+
+  @Test def backticksCompleteBoth: Unit = {
+    val expected = Set(
+      ("formatted", Method, "(fmtstr: String): String"),
+      ("`foo-bar`", Field, "Int"),
+      ("foo", Field, "Int")
+    )
+    code"""object Foo:
+           |  object Bar:
+           |    val foo = 1
+           |    val `foo-bar` = 2
+           |    val `bar` = 3
+           |  
+           |  val x = Bar.fo${m1}"""
+             .withSource.completion(m1, expected)
+  }
+
+  @Test def backticksWhenNotNeeded: Unit = {
+    val expected = Set(
+      ("`formatted`", Method, "(fmtstr: String): String"),
+      ("`foo-bar`", Field, "Int"),
+      ("`foo`", Field, "Int")
+    )
+    code"""object Foo:
+           |  object Bar:
+           |    val foo = 1
+           |    val `foo-bar` = 2
+           |  
+           |  val x = Bar.`fo${m1}"""
+             .withSource.completion(m1, expected)
+  }
 }