fix typo and unassigned terms conversion

Author: rochala

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

@@ -493,7 +493,7 @@ object Completion {
      * from T to S. It then applies conversion method for proper type parameter resolution.
      *
      * @param qual The argument to which the implicit conversion should be applied.
-     * @return Types after implicit conversion.
+     * @return The set of types after `qual` implicit conversion.
      */
     private def implicitConversionTargets(qual: Tree)(using Context): Set[Type] = {
       val typer = ctx.typer

compiler/src/dotty/tools/dotc/typer/Applications.scala

@@ -2300,15 +2300,15 @@ trait Applications extends Compatibility {
 
     try
       val appliedTree = inContext(newCtx) {
-        newCtx.typer.typed(untpd.Apply(conversionMethodTree, (receiver:: Nil)))
+        typed(untpd.Apply(conversionMethodTree, untpd.TypedSplice(receiver) :: Nil))
       }
 
       if appliedTree.tpe.exists && !appliedTree.tpe.isError then
         Some(appliedTree)
       else
         None
     catch
-      case NonFatal(_) => None
+      case NonFatal(x) => None
 
   def isApplicableExtensionMethod(methodRef: TermRef, receiverType: Type)(using Context): Boolean =
     methodRef.symbol.is(ExtensionMethod) && !receiverType.isBottomType &&

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

@@ -1200,8 +1200,8 @@ class CompletionTest {
           |}
           |implicit def fooToBoo[A](x: Foo[A]): Boo[A] = Boo(x.x)
           |case class Bar[F[_]](bar: F[Int])
-          |def foo(x: Bar[M]) = x.bar.m${m1}"""
-      .withSource.completion(m1, expected)
+          |def foo(x: Bar[M]) = x.bar.m${m1}""".withSource
+      .completion(m1, expected)
   }
 
   @Test def higherKindedTypeInferenceTest: Unit = {
@@ -1216,8 +1216,8 @@ class CompletionTest {
           |  val test = new Test[Int, String] {}
           |  test.foo${m1}
           |  (new Test[Int, String] {}).foo${m2}""".withSource
-            .completion(m1, expected)
-            .completion(m2, expected)
+      .completion(m1, expected)
+      .completion(m2, expected)
   }
 
   @Test def higherKindedImplicitConversionsCompletions: Unit = {
@@ -1231,12 +1231,14 @@ class CompletionTest {
           |}
           |case class Boo[C](x: C) {
           |  def mapBoo[B](f: C => B): Boo[B] = ???
-          }
+          |}
           |implicit def fooToBoo[D](x: Foo[D]): Boo[D] = Boo(x.x)
           |object Test:
           |  val x = Foo(1)
-          |  x.ma${m1}"""
-            .withSource.completion(m1, expected)
+          |  x.ma${m1}
+          |  Foo(1).ma${m2}""".withSource
+      .completion(m1, expected)
+      .completion(m2, expected)
   }
 
   @Test def higherKindedMatchTypeExtensionMethodCompletion: Unit = {