add support for precise typing with implicit conversions.

for this purpose, additional context was required in `TyperState`.
a stack was used for the conversion history.
Also, a more general fix for scala#12802 was applied.

Author: soronpo

compiler/src/dotty/tools/dotc/core/TyperState.scala

@@ -12,6 +12,7 @@ import collection.mutable
 import java.lang.ref.WeakReference
 import util.{Stats, SimpleIdentityMap}
 import Decorators._
+import ast.tpd.Tree
 
 import scala.annotation.internal.sharable
 
@@ -24,21 +25,23 @@ object TyperState {
       .setCommittable(true)
 
   type LevelMap = SimpleIdentityMap[TypeVar, Integer]
+  type PreciseConversionStack = List[Set[Tree]]
 
-  opaque type Snapshot = (Constraint, TypeVars, LevelMap)
+  opaque type Snapshot = (Constraint, TypeVars, LevelMap, PreciseConversionStack)
 
   extension (ts: TyperState)
     def snapshot()(using Context): Snapshot =
-      (ts.constraint, ts.ownedVars, ts.upLevels)
+      (ts.constraint, ts.ownedVars, ts.upLevels, ts.myPreciseConvStack)
 
     def resetTo(state: Snapshot)(using Context): Unit =
-      val (constraint, ownedVars, upLevels) = state
+      val (constraint, ownedVars, upLevels, myPreciseConvStack) = state
       for tv <- ownedVars do
         if !ts.ownedVars.contains(tv) then // tv has been instantiated
           tv.resetInst(ts)
       ts.constraint = constraint
       ts.ownedVars = ownedVars
       ts.upLevels = upLevels
+      ts.myPreciseConvStack = myPreciseConvStack
 }
 
 class TyperState() {
@@ -93,6 +96,23 @@ class TyperState() {
 
   private var upLevels: LevelMap = _
 
+  // Stack can be empty and precise conversion occur in `val x : Foo = from`
+  // where `from` is implicitly and precisely converted into `Foo`. We don't
+  // care about these conversions.
+  private var myPreciseConvStack: List[Set[Tree]] = _
+  def hasPreciseConversion(tree: Tree): Boolean =
+    myPreciseConvStack match
+      case head :: _ => head.contains(tree)
+      case _ => false
+  def addPreciseConversion(tree: Tree): Unit =
+    myPreciseConvStack = myPreciseConvStack match
+      case head :: tail => (head + tree) :: tail
+      case _ => myPreciseConvStack
+  def pushPreciseConversionStack(): Unit  =
+    myPreciseConvStack = Set.empty[Tree] :: myPreciseConvStack
+  def popPreciseConversionStack(): Unit =
+    myPreciseConvStack = myPreciseConvStack.drop(1)
+
   /** Initializes all fields except reporter, isCommittable, which need to be
    *  set separately.
    */
@@ -105,6 +125,7 @@ class TyperState() {
     this.myOwnedVars = SimpleIdentitySet.empty
     this.upLevels = SimpleIdentityMap.empty
     this.isCommitted = false
+    this.myPreciseConvStack = Nil
     this
 
   /** A fresh typer state with the same constraint as this one. */
@@ -115,6 +136,7 @@ class TyperState() {
       .setReporter(reporter)
       .setCommittable(committable)
     ts.upLevels = upLevels
+    ts.myPreciseConvStack = myPreciseConvStack
     ts
 
   /** The uninstantiated variables */
@@ -162,6 +184,8 @@ class TyperState() {
     assert(!isCommitted, s"$this is already committed")
     val targetState = ctx.typerState
 
+    targetState.myPreciseConvStack = myPreciseConvStack
+
     val nothingToCommit = (constraint eq targetState.constraint) && !reporter.hasUnreportedMessages
     assert(!targetState.isCommitted || nothingToCommit ||
        // Committing into an already committed TyperState usually doesn't make

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

@@ -891,7 +891,7 @@ trait Applications extends Compatibility {
    */
   def typedApply(tree: untpd.Apply, pt: Type)(using Context): Tree = {
 
-    def realApply(using Context): Tree = {
+    def realApply(argsPrecises: List[Boolean] = Nil)(using Context): Tree = {
       val resultProto = tree.fun match
         case Select(New(tpt), _) if pt.isInstanceOf[ValueType] =>
           if tpt.isType && typedAheadType(tpt).tpe.typeSymbol.typeParams.isEmpty then
@@ -905,7 +905,7 @@ trait Applications extends Compatibility {
           // Do ignore other expected result types, since there might be an implicit conversion
           // on the result. We could drop this if we disallow unrestricted implicit conversions.
       val originalProto =
-        new FunProto(tree.args, resultProto)(this, tree.applyKind)(using argCtx(tree))
+        new FunProto(tree.args, resultProto)(this, tree.applyKind, argsPrecises = argsPrecises)(using argCtx(tree))
       record("typedApply")
       val fun1 = typedExpr(tree.fun, originalProto)
 
@@ -1015,6 +1015,41 @@ trait Applications extends Compatibility {
       }
     }
 
+    /** Attempts to run `realApply`, and if implicit conversions should be
+     *  precise, then re-run `realApply` with the precise enforcement.
+     */
+    def realApplyWithRetry(using Context): Tree = {
+      ctx.typerState.pushPreciseConversionStack()
+      val firstAttemptCtx = ctx.fresh.setNewTyperState()
+      // tuple application for tuple return type gets special treatment when arguments are precise
+      val argsPrecises = (tree.fun, pt.dealias) match
+        case (untpd.TypedSplice(fun), AppliedType(_, args))
+          if defn.isTupleClass(fun.tpe.classSymbol.companionClass) && defn.isTupleNType(pt) =>
+          args.map(_.isPrecise)
+        case _ => Nil
+      val app = realApply(argsPrecises)(using firstAttemptCtx)
+      val retTree = app match
+        // If we are already in precise mode, then the arguments are already typed precisely,
+        // so there is no need for any additional logic.
+        case Apply(_, args) if !ctx.mode.is(Mode.Precise) =>
+          val convArgsPrecises = args.map(firstAttemptCtx.typerState.hasPreciseConversion)
+          if (convArgsPrecises.contains(true))
+            val preciseCtx = ctx.fresh.setNewTyperState()
+            val updatedPrecises =
+              if (argsPrecises.nonEmpty) convArgsPrecises.lazyZip(argsPrecises).map(_ || _)
+              else convArgsPrecises
+            val app = realApply(updatedPrecises)(using preciseCtx)
+            preciseCtx.typerState.commit()
+            app
+          else
+            firstAttemptCtx.typerState.commit()
+            app
+        case _ =>
+          firstAttemptCtx.typerState.commit()
+          app
+      ctx.typerState.popPreciseConversionStack()
+      retTree
+    }
     /** Convert expression like
      *
      *     e += (args)
@@ -1037,7 +1072,7 @@ trait Applications extends Compatibility {
     val app1 =
       if (untpd.isOpAssign(tree))
         tryEither {
-          realApply
+          realApplyWithRetry
         } { (failedVal, failedState) =>
           tryEither {
             typedOpAssign
@@ -1049,7 +1084,7 @@ trait Applications extends Compatibility {
       else {
         val app = tree.fun match
           case _: untpd.Splice if ctx.mode.is(Mode.QuotedPattern) => typedAppliedSplice(tree, pt)
-          case _ => realApply
+          case _ => realApplyWithRetry
         app match {
           case Apply(fn @ Select(left, _), right :: Nil) if fn.hasType =>
             val op = fn.symbol

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

@@ -1013,6 +1013,7 @@ trait Implicits:
         // would cause a cyclic reference error (if the import is named) or cause a
         // spurious import skip (if the import is a wildcard import). See i12802 for a test case.
         var searchCtx = ctx
+        while searchCtx.outer.owner.isImport do searchCtx = searchCtx.outer
         if ctx.owner.isImport then
           while
             searchCtx = searchCtx.outer

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

@@ -4019,6 +4019,29 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
             case SearchSuccess(found, _, _, isExtension) =>
               if isExtension then found
               else
+                object Extract:
+                  @tailrec def unapply(tree: Tree): Option[Tree] =
+                    tree match
+                      case Apply(tree, _) => unapply(tree)
+                      case Select(tree, _) => unapply(tree)
+                      case Inlined(tree, _, _) => unapply(tree)
+                      case ta: TypeApply => Some(ta.fun)
+                      case _ => None
+                found match
+                  case Extract(fun) =>
+                    fun.tpe.widen match
+                      case pt: PolyType => pt.resType match
+                        case mt: MethodType => mt.paramInfos.headOption.foreach {
+                          case v if v.isPrecise =>
+                            ctx.typerState.addPreciseConversion(found)
+                          case _ =>
+                        }
+                        case AppliedType(tycon, from :: _)
+                          if tycon.derivesFrom(defn.ConversionClass) && from.isPrecise =>
+                          ctx.typerState.addPreciseConversion(found)
+                        case _ =>
+                      case _ =>
+                  case _ =>
                 checkImplicitConversionUseOK(found)
                 withoutMode(Mode.ImplicitsEnabled)(readapt(found))
             case failure: SearchFailure =>