moved logic from application to typer

Author: soronpo

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

@@ -901,30 +901,10 @@ trait Applications extends Compatibility {
         case _ => IgnoredProto(pt)
           // 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.
-      def protogen(argsPrecises: List[Boolean] = Nil) =
-            new FunProto(tree.args, resultProto)(this, tree.applyKind, argsPrecises = argsPrecises)(using argCtx(tree))
-      var originalProto = protogen()
-      def getFunTyped = typedExpr(tree.fun, originalProto)
+      val originalProto =
+        new FunProto(tree.args, resultProto)(this, tree.applyKind)(using argCtx(tree))
       record("typedApply")
-      extension (tpe: Type) def getArgsPrecises: List[Boolean] = tpe.widen match
-        case mt: MethodType =>
-          mt.paramInfos.map {
-            case v: TypeVar => v.origin.isPrecise
-            case _ => false
-          }
-        case _ => Nil
-      val stateBkp = ctx.typerState.snapshot()
-      val fun1MaybePrecise = getFunTyped
-      val funTpe = fun1MaybePrecise.tpe
-      val argsPrecises = funTpe.getArgsPrecises
-      val fun1 =
-        // `fun` may be precise and from overloaded function. If so, then we need another typer pass, with the
-        // proper precise enforcements on the relevant arguments
-        if (argsPrecises.exists(b => b))
-          ctx.typerState.resetTo(stateBkp)
-          originalProto = protogen(argsPrecises)
-          getFunTyped
-        else fun1MaybePrecise
+      val fun1 = typedExpr(tree.fun, originalProto)
 
       // If adaptation created a tupled dual of `originalProto`, pick the right version
       // (tupled or not) of originalProto to proceed.

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

@@ -328,7 +328,7 @@ object ProtoTypes {
   case class FunProto(args: List[untpd.Tree], resType: Type)(
     typer: Typer,
     override val applyKind: ApplyKind,
-    state: FunProtoState = new FunProtoState,
+    private var state: FunProtoState = new FunProtoState,
     val constrainResultDeep: Boolean = false,
     val argsPrecises: List[Boolean] = Nil
   )(using protoCtx: Context)
@@ -343,6 +343,9 @@ object ProtoTypes {
       typer.isApplicableType(tp, args, resultType, keepConstraint && !args.exists(isPoly))
     }
 
+    def snapshot: FunProtoState = state
+    def resetTo(prevState: FunProtoState): Unit = state = prevState
+
     def derivedFunProto(
         args: List[untpd.Tree] = this.args,
         resultType: Type = this.resultType,

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

@@ -3028,7 +3028,49 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         typed(tree, pt, locked)(using ctx.withSource(tree.source))
       else if ctx.run.nn.isCancelled then
         tree.withType(WildcardType)
-      else adapt(typedUnadapted(tree, pt, locked), pt, locked)
+      else
+        val tu = typedUnadapted(tree, pt, locked)
+        pt match
+          case pt : FunProto =>
+            extension (tpe: Type) def getArgsPrecises: List[Boolean] = tpe.widen match
+              case mt: MethodType =>
+                mt.paramInfos.map {
+                  case v: TypeVar => v.origin.isPrecise
+                  case _ => false
+                }
+              case _ => Nil
+            val argsPrecises = tu.tpe.getArgsPrecises
+            // if the function arguments are known to be precise, then we update the
+            // proto with this information and later propagate its state back to the
+            // original proto.
+            if (argsPrecises.contains(true))
+              val ptPrecises = pt.derivedFunProto(argsPrecises = argsPrecises)
+              val adapted = adapt(tu, ptPrecises, locked)
+              pt.resetTo(ptPrecises.snapshot)
+              adapted
+            // otherwise, we need to check for overloaded function, because in that
+            // case we may not know if the final adapted function will be precise.
+            else tu.tpe match
+              // the function is overloaded, so we preserve the typer and proto state,
+              // adapt the tree, and then check if the arguments should be considered as
+              // precise. if so, then we need to recover the typer state and proto
+              // state, and re-adapt the tree with the precise enforcement.
+              case v: TermRef if v.isOverloaded =>
+                val savedTyperState = ctx.typerState.snapshot()
+                val savedProtoState = pt.snapshot
+                val adaptedMaybePrecise = adapt(tu, pt, locked)
+                val argsPrecises = adaptedMaybePrecise.tpe.getArgsPrecises
+                if (argsPrecises.contains(true))
+                  val ptPrecises = pt.derivedFunProto(argsPrecises = argsPrecises)
+                  ctx.typerState.resetTo(savedTyperState)
+                  pt.resetTo(savedProtoState)
+                  val adapted = adapt(tu, ptPrecises, locked)
+                  pt.resetTo(ptPrecises.snapshot)
+                  adapted
+                else adaptedMaybePrecise
+              // the function is not overloaded or has precise arguments
+              case _ => adapt(tu, pt, locked)
+          case _ => adapt(tu, pt, locked)
     }
 
   def typed(tree: untpd.Tree, pt: Type = WildcardType)(using Context): Tree =

tests/neg/precise-type-params.scala

@@ -207,3 +207,4 @@ object preciseInTheWrongPlaceError:
   @precise def err2: Unit = {} // error
   @precise val err3: Int = 0 // error
   class err4[A <: Int @precise] // error
+  @precise object err5 // error