Add missing span to extension method select

Author: kasiaMarek

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

@@ -512,7 +512,7 @@ object Completion {
      */
     private def implicitConversionTargets(qual: Tree)(using Context): Set[Type] = {
       val typer = ctx.typer
-      val conversions = new typer.ImplicitSearch(defn.AnyType, qual, pos.span).allImplicits
+      val conversions = new typer.ImplicitSearch(defn.AnyType, qual, pos.span, None).allImplicits
       val targets = conversions.map(_.tree.tpe)
 
       interactiv.println(i"implicit conversion targets considered: ${targets.toList}%, %")

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

@@ -860,7 +860,7 @@ trait Implicits:
   /** Find an implicit conversion to apply to given tree `from` so that the
    *  result is compatible with type `to`.
    */
-  def inferView(from: Tree, to: Type)(using Context): SearchResult = {
+  def inferView(from: Tree, to: Type, maybeNameSpan: Option[Span] = None)(using Context): SearchResult = {
     record("inferView")
     if !ctx.mode.is(Mode.ImplicitsEnabled) || from.isInstanceOf[Super] then
       NoMatchingImplicitsFailure
@@ -878,7 +878,7 @@ trait Implicits:
         }
 
       try
-        val inferred = inferImplicit(adjust(to), from, from.span)
+        val inferred = inferImplicit(adjust(to), from, from.span, maybeNameSpan)
 
         inferred match {
           case SearchSuccess(_, ref, _, false) if isOldStyleFunctionConversion(ref.underlying) =>
@@ -1059,7 +1059,7 @@ trait Implicits:
    *                         it should be applied, EmptyTree otherwise.
    *  @param span            The position where errors should be reported.
    */
-  def inferImplicit(pt: Type, argument: Tree, span: Span)(using Context): SearchResult =
+  def inferImplicit(pt: Type, argument: Tree, span: Span, maybeNameSpan: Option[Span] = None)(using Context): SearchResult =
     trace(s"search implicit ${pt.show}, arg = ${argument.show}: ${argument.tpe.show}", implicits, show = true) {
       record("inferImplicit")
       assert(ctx.phase.allowsImplicitSearch,
@@ -1082,7 +1082,7 @@ trait Implicits:
             (searchCtx.scope eq ctx.scope) && (searchCtx.owner eq ctx.owner.owner)
           do ()
 
-        try ImplicitSearch(pt, argument, span)(using searchCtx).bestImplicit
+        try ImplicitSearch(pt, argument, span, maybeNameSpan)(using searchCtx).bestImplicit
         catch case ce: CyclicReference =>
           ce.inImplicitSearch = true
           throw ce
@@ -1102,9 +1102,9 @@ trait Implicits:
             result
           case result: SearchFailure if result.isAmbiguous =>
             val deepPt = pt.deepenProto
-            if (deepPt ne pt) inferImplicit(deepPt, argument, span)
+            if (deepPt ne pt) inferImplicit(deepPt, argument, span, maybeNameSpan)
             else if (migrateTo3 && !ctx.mode.is(Mode.OldOverloadingResolution))
-              withMode(Mode.OldOverloadingResolution)(inferImplicit(pt, argument, span)) match {
+              withMode(Mode.OldOverloadingResolution)(inferImplicit(pt, argument, span, maybeNameSpan)) match {
                 case altResult: SearchSuccess =>
                   report.migrationWarning(
                     result.reason.msg
@@ -1125,7 +1125,7 @@ trait Implicits:
     }
 
   /** Try to typecheck an implicit reference */
-  def typedImplicit(cand: Candidate, pt: Type, argument: Tree, span: Span)(using Context): SearchResult =  trace(i"typed implicit ${cand.ref}, pt = $pt, implicitsEnabled == ${ctx.mode is ImplicitsEnabled}", implicits, show = true) {
+  def typedImplicit(cand: Candidate, pt: Type, argument: Tree, span: Span, maybeNameSpan: Option[Span] = None)(using Context): SearchResult =  trace(i"typed implicit ${cand.ref}, pt = $pt, implicitsEnabled == ${ctx.mode is ImplicitsEnabled}", implicits, show = true) {
     if ctx.run.nn.isCancelled then NoMatchingImplicitsFailure
     else
       record("typedImplicit")
@@ -1164,7 +1164,9 @@ trait Implicits:
             case selProto @ SelectionProto(selName: TermName, mbrType, _, _) =>
 
               def tryExtension(using Context) =
-                extMethodApply(untpd.Select(untpdGenerated, selName), argument, mbrType)
+                val select =
+                  maybeNameSpan.foldLeft(untpd.Select(untpdGenerated, selName))(_.withSpan(_))
+                extMethodApply(select, argument, mbrType)
 
               def tryConversionForSelection(using Context) =
                 val converted = tryConversion
@@ -1215,7 +1217,7 @@ trait Implicits:
     }
 
   /** An implicit search; parameters as in `inferImplicit` */
-  class ImplicitSearch(protected val pt: Type, protected val argument: Tree, span: Span)(using Context):
+  class ImplicitSearch(protected val pt: Type, protected val argument: Tree, span: Span, maybeNameSpan: Option[Span])(using Context):
     assert(argument.isEmpty || argument.tpe.isValueType || argument.tpe.isInstanceOf[ExprType],
         em"found: $argument: ${argument.tpe}, expected: $pt")
 
@@ -1264,7 +1266,7 @@ trait Implicits:
         val history = ctx.searchHistory.nest(cand, pt)
         val typingCtx =
           nestedContext().setNewTyperState().setFreshGADTBounds.setSearchHistory(history)
-        val result = typedImplicit(cand, pt, argument, span)(using typingCtx)
+        val result = typedImplicit(cand, pt, argument, span, maybeNameSpan)(using typingCtx)
         result match
           case res: SearchSuccess =>
             ctx.searchHistory.defineBynameImplicit(wideProto, res)

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

@@ -179,7 +179,7 @@ class ReTyper(nestingLevel: Int = 0) extends Typer(nestingLevel) with ReChecking
 
   override def inlineExpansion(mdef: DefDef)(using Context): List[Tree] = mdef :: Nil
 
-  override def inferView(from: Tree, to: Type)(using Context): Implicits.SearchResult =
+  override def inferView(from: Tree, to: Type, maybeNameSpan: Option[Span] = None)(using Context): Implicits.SearchResult =
     Implicits.NoMatchingImplicitsFailure
   override def checkCanEqual(ltp: Type, rtp: Type, span: Span)(using Context): Unit = ()
 

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

@@ -3598,7 +3598,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     if ctx.mode.is(Mode.ImplicitsEnabled) && !tree.name.isConstructorName && qual.tpe.isValueType then
       try
         val selProto = selectionProto
-        trace(i"try insert impl on qualifier $tree $pt") { inferView(qual, selProto) } match
+        trace(i"try insert impl on qualifier $tree $pt") { inferView(qual, selProto, Some(tree.nameSpan)) } match
           case SearchSuccess(found, _, _, isExtension) =>
             if isExtension then return found
             else

presentation-compiler/test/dotty/tools/pc/tests/definition/PcDefinitionSuite.scala

@@ -401,3 +401,13 @@ class PcDefinitionSuite extends BasePcDefinitionSuite:
          |
          |""".stripMargin
     )
+
+  @Test def `implicit-extension` =
+    check(
+      """|class MyIntOut(val value: Int)
+         |object MyIntOut:
+         |  extension (i: MyIntOut) def <<uneven>> = i.value % 2 == 1
+         |
+         |val a = MyIntOut(1).un@@even
+         |""".stripMargin,
+    )

presentation-compiler/test/dotty/tools/pc/tests/highlight/DocumentHighlightSuite.scala

@@ -1143,3 +1143,14 @@ class DocumentHighlightSuite extends BaseDocumentHighlightSuite:
          |  case MySome[<<AA>>](value: <<A@@A>>) extends MyOption[Int]
          |""".stripMargin,
     )
+
+  @Test def `implicit-extension` =
+    check(
+      """|class MyIntOut(val value: Int)
+         |object MyIntOut:
+         |  extension (i: MyIntOut) def <<uneven>> = i.value % 2 == 1
+         |
+         |val a = MyIntOut(1)
+         |val m = a.<<un@@even>>
+         |""".stripMargin,
+    )