fix: handle backticked names in inffered-type

mtags/src/main/scala-2/scala/meta/internal/pc/InferredTypeProvider.scala

@@ -60,14 +60,20 @@ final class InferredTypeProvider(
     def prettyType(tpe: Type) =
       metalsToLongString(tpe.widen.finalResultType, history)
 
+    def findNameEnd(start: Int, name: Name): Int = {
+      // dropLocal will remove a space that might appear at the of a name in some places
+      val identLength = name.dropLocal.length
+      val backtickInc = if (params.text().charAt(start) == '`') 2 else 0
+      start + identLength + backtickInc
+    }
+
     typedTree match {
       /* `val a = 1` or `var b = 2`
        *     turns into
        * `val a: Int = 1` or `var b: Int = 2`
        */
       case vl @ ValDef(_, name, tpt, _) if !vl.symbol.isParameter =>
-        // dropLocal will remove a space that might appear at the of a name in some places
-        val nameEnd = tpt.pos.start + name.dropLocal.length()
+        val nameEnd = findNameEnd(tpt.pos.start, name)
         val nameEndPos = tpt.pos.withEnd(nameEnd).withStart(nameEnd).toLSP
         val typeNameEdit = new TextEdit(nameEndPos, ": " + prettyType(tpt.tpe))
         typeNameEdit :: additionalImports
@@ -77,7 +83,7 @@ final class InferredTypeProvider(
        * `.map((a: Int) => a + a)`
        */
       case vl @ ValDef(_, name, tpt, _) if vl.symbol.isParameter =>
-        val nameEnd = vl.pos.start + name.length()
+        val nameEnd = findNameEnd(vl.pos.start, name)
         val namePos = tpt.pos.withEnd(nameEnd).withStart(nameEnd).toLSP
 
         def leftParenStart = vl.pos.withEnd(vl.pos.start).toLSP
@@ -120,7 +126,7 @@ final class InferredTypeProvider(
        * `def a[T](param : Int): Int = param`
        */
       case DefDef(_, name, _, _, tpt, rhs) =>
-        val nameEnd = tpt.pos.start + name.length()
+        val nameEnd = findNameEnd(tpt.pos.start, name)
 
         // search for `)` or `]` or defaut to name's end to insert type
         val searchString = params
@@ -148,7 +154,7 @@ final class InferredTypeProvider(
         def openingParenPos = body.pos.withEnd(body.pos.start)
         def openingParen = new TextEdit(openingParenPos.toLSP, "(")
 
-        val insertStart = bind.pos.start + name.length()
+        val insertStart = findNameEnd(bind.pos.start, name)
         val insertPos = bind.pos.withEnd(insertStart).withStart(insertStart)
 
         /* In case it's an infix pattern match

mtags/src/main/scala-3/scala/meta/internal/pc/InferredTypeProvider.scala

@@ -17,13 +17,16 @@ import scala.meta.tokens.{Token as T}
 import dotty.tools.dotc.ast.Trees.*
 import dotty.tools.dotc.ast.untpd
 import dotty.tools.dotc.core.Contexts.*
+import dotty.tools.dotc.core.NameOps.*
+import dotty.tools.dotc.core.Names.*
 import dotty.tools.dotc.core.Symbols.*
 import dotty.tools.dotc.core.Types.*
 import dotty.tools.dotc.interactive.Interactive
 import dotty.tools.dotc.interactive.InteractiveDriver
 import dotty.tools.dotc.util.SourceFile
 import dotty.tools.dotc.util.SourcePosition
 import dotty.tools.dotc.util.Spans
+import dotty.tools.dotc.util.Spans.Span
 import org.eclipse.lsp4j.TextEdit
 
 /**
@@ -121,9 +124,10 @@ final class InferredTypeProvider(
        */
       case Some(vl @ ValDef(sym, tpt, _)) =>
         val isParam = path.tail.headOption.exists(_.symbol.isAnonymousFunction)
-        def baseEdit(withParens: Boolean) =
+        def baseEdit(withParens: Boolean): TextEdit =
+          val endPos = findNamePos(params.text, vl).endPos
           new TextEdit(
-            vl.namePos.endPos.toLSP,
+            endPos.toLSP,
             ": " + printType(tpt.tpe) + {
               if withParens then ")" else ""
             }
@@ -134,7 +138,7 @@ final class InferredTypeProvider(
             toCheckFor: Char,
             blockStartPos: SourcePosition
         ) =
-          val text = params.text.toString()
+          val text = params.text
           val isParensFunction: Boolean = text(applyEndingPos) == toCheckFor
 
           val alreadyHasParens =
@@ -251,4 +255,41 @@ final class InferredTypeProvider(
     end match
   end inferredTypeEdits
 
+  private def findNamePos(text: String, tree: untpd.NamedDefTree)(using
+      Context
+  ): SourcePosition =
+    val realName = tree.name.stripModuleClassSuffix.toString.toList
+
+    // `NamedDefTree.namePos` is incorrect for bacticked names
+    @tailrec
+    def lookup(
+        idx: Int,
+        start: Option[(Int, List[Char])],
+        withBacktick: Boolean
+    ): Option[SourcePosition] =
+      start match
+        case Some((start, nextMatch :: left)) =>
+          if text.charAt(idx) == nextMatch then
+            lookup(idx + 1, Some((start, left)), withBacktick)
+          else lookup(idx + 1, None, withBacktick = false)
+        case Some((start, Nil)) =>
+          val end = if withBacktick then idx + 1 else idx
+          val pos = tree.source.atSpan(Span(start, end, start))
+          Some(pos)
+        case None if idx < text.length =>
+          val ch = text.charAt(idx)
+          if ch == realName.head then
+            lookup(idx + 1, Some((idx, realName.tail)), withBacktick)
+          else if ch == '`' then lookup(idx + 1, None, withBacktick = true)
+          else lookup(idx + 1, None, withBacktick = false)
+        case _ =>
+          None
+
+    val macthedByText =
+      if realName.nonEmpty then lookup(tree.sourcePos.start, None, false)
+      else None
+
+    macthedByText.getOrElse(tree.namePos)
+  end findNamePos
+
 end InferredTypeProvider

tests/cross/src/test/scala/tests/pc/InsertInferredTypeSuite.scala

@@ -478,6 +478,39 @@ class InsertInferredTypeSuite extends BaseCodeActionSuite {
     )
   )
 
+  checkEdit(
+    "backticks-1",
+    """|object O{
+       |  val <<`bar`>> = 42
+       |}""".stripMargin,
+    """|object O{
+       |  val `bar`: Int = 42
+       |}
+       |""".stripMargin
+  )
+
+  checkEdit(
+    "backticks-2",
+    """|object O{
+       |  def <<`bar`>> = 42
+       |}""".stripMargin,
+    """|object O{
+       |  def `bar`: Int = 42
+       |}
+       |""".stripMargin
+  )
+
+  checkEdit(
+    "backticks-3",
+    """|object O{
+       |  List(1).map(<<`a`>> => a + 1)
+       |}""".stripMargin,
+    """|object O{
+       |  List(1).map((`a`: Int) => a + 1)
+       |}
+       |""".stripMargin
+  )
+
   def checkEdit(
       name: TestOptions,
       original: String,