Try to extract name when backtick is missing

Previously, completion prefix would show up as an empty string if we had an unclosed backtick. Now, we try to extract the prefix from the file contents in that case.

An alternative approach would be to tranfer somehow the name string  in `nme.Error`, but I didn't see anything like that done before, so not sure how to properly address that.

Fixes #12514

Author: tgodzik

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

@@ -92,7 +92,14 @@ object Completion {
         }.getOrElse("")
 
       case (ref: untpd.RefTree) :: _ =>
-        if (ref.name == nme.ERROR) ""
+        if (ref.name == nme.ERROR) {
+          val content = ref.source.content()
+          // if the error resulted from unclosed back tick
+          if content(ref.span.start) == '`' then
+            content.slice(ref.span.start + 1, ref.span.end).mkString
+          else
+            ""
+        }
         else ref.name.toString.take(pos.span.point - ref.span.point)
 
       case _ =>

compiler/test/dotty/tools/repl/TabcompleteTests.scala

@@ -138,4 +138,50 @@ class TabcompleteTests extends ReplTest {
       tabComplete("import quoted.* ; def fooImpl(using Quotes): Expr[Int] = { import quotes.reflect.* ; TypeRepr.of[Int].s"))
   }
 
+  @Test def wrongAnyMember: Unit =  fromInitialState { implicit s =>
+    assertEquals(List("scalaUtilChainingOps"), tabComplete("import scala.util.chaining.`sc"))
+  }
+
+  @Test def importBackticked: Unit = {
+    fromInitialState { implicit state  =>
+      val src = """|object O{
+                   | val `extends` = ""
+                   |}
+                   |""".stripMargin
+      run(src)
+    }
+    .andThen { implicit state =>
+      val expected = List("extends")
+      assertEquals(expected, tabComplete("import O.`extends`"))
+    }
+  }
+
+  @Test def importBacktickedUnclosed: Unit = {
+    fromInitialState { implicit state  =>
+      val src = """|object O{
+                   | val `extends` = ""
+                   |}
+                   |""".stripMargin
+      run(src)
+    }
+    .andThen { implicit state =>
+      val expected = List("extends")
+      assertEquals(expected, tabComplete("import O.`extends"))
+    }
+  }
+
+
+  @Test def importBacktickedUnclosedSpace: Unit = {
+    fromInitialState { implicit state  =>
+      val src = """|object O{
+                   | val `extends ` = ""
+                   |}
+                   |""".stripMargin
+      run(src)
+    }
+    .andThen { implicit state =>
+      val expected = List("extends ")
+      assertEquals(expected, tabComplete("import O.`extends"))
+    }
+  }
 }

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

@@ -887,4 +887,38 @@ class CompletionTest {
           )
         )
   }
+
+  @Test def wrongAnyMember: Unit = {
+    code"""|import scala.util.chaining.`sc${m1}
+           |""".withSource
+      .completion(m1, Set(("scalaUtilChainingOps",Method,"[A](a: A): scala.util.ChainingOps[A]")))
+  }
+
+  @Test def importBackticked: Unit = {
+    code"""|object O{
+           | val `extends` = ""
+           |}
+           |import O.`extends`${m1}
+           |""".withSource
+      .completion(m1, Set(("extends",Field,"String")))
+  }
+
+  @Test def importBacktickedUnclosed: Unit = {
+    code"""|object O{
+           | val `extends` = ""
+           |}
+           |import O.`extends${m1}
+           |""".withSource
+      .completion(m1, Set(("extends",Field,"String")))
+  }
+
+
+  @Test def importBacktickedUnclosedSpace: Unit = {
+  code"""|object O{
+         | val `extends ` = ""
+         |}
+         |import O.`extends ${m1}
+         |""".withSource
+    .completion(m1, Set(("extends ",Field,"String")))
+  }
 }