Improve treatment of typedArgs

Author: odersky

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

@@ -144,9 +144,8 @@ class TyperState(previous: TyperState /* | Null */) {
     Stats.record("typerState.commit")
     val targetState = ctx.typerState
     assert(isCommittable)
-    targetState.constraint =
-      if (targetState.constraint eq previousConstraint) constraint
-      else targetState.constraint & (constraint, otherHasErrors = reporter.errorsReported)
+    if (targetState.constraint eq previousConstraint) targetState.constraint = constraint
+    else targetState.mergeConstraintWith(this)
     constraint foreachTypeVar { tvar =>
       if (tvar.owningState.get eq this) tvar.owningState = new WeakReference(targetState)
     }
@@ -156,6 +155,9 @@ class TyperState(previous: TyperState /* | Null */) {
     isCommitted = true
   }
 
+  def mergeConstraintWith(that: TyperState)(implicit ctx: Context): Unit =
+    constraint = constraint & (that.constraint, otherHasErrors = that.reporter.errorsReported)
+
   /** Make type variable instances permanent by assigning to `inst` field if
    *  type variable instantiation cannot be retracted anymore. Then, remove
    *  no-longer needed constraint entries.

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

@@ -244,7 +244,7 @@ object ProtoTypes {
    *  [](args): resultType
    */
   case class FunProto(args: List[untpd.Tree], resType: Type)(typer: Typer,
-    override val isContextual: Boolean, state: FunProtoState = new FunProtoState)(implicit ctx: Context)
+    override val isContextual: Boolean, state: FunProtoState = new FunProtoState)(implicit val ctx: Context)
   extends UncachedGroundType with ApplyingProto with FunOrPolyProto {
     override def resultType(implicit ctx: Context): Type = resType
 
@@ -298,13 +298,26 @@ object ProtoTypes {
 
     /** The typed arguments. This takes any arguments already typed using
      *  `typedArg` into account.
+     *
+     *  Arguments are typechecked in the typerState where the FunProto was created.
+     *  However, any constraint changes are also propagated to the currently passed
+     *  context.
+     *
      */
-    def unforcedTypedArgs: List[Tree] =
+    def unforcedTypedArgs(implicit ctx: Context): List[Tree] =
       if (state.typedArgs.size == args.length) state.typedArgs
       else {
-        val args1 = args.mapconserve(cacheTypedArg(_, typer.typed(_), force = false))
-        if (!args1.exists(arg => isUndefined(arg.tpe))) state.typedArgs = args1
-        args1
+        val prevConstraint = this.ctx.typerState.constraint
+
+        try {
+          implicit val ctx = this.ctx
+          val args1 = args.mapconserve(cacheTypedArg(_, typer.typed(_), force = false))
+          if (!args1.exists(arg => isUndefined(arg.tpe))) state.typedArgs = args1
+          args1
+        }
+        finally
+          if (this.ctx.typerState.constraint ne prevConstraint)
+            ctx.typerState.mergeConstraintWith(this.ctx.typerState)
       }
 
     /** Type single argument and remember the unadapted result in `myTypedArg`.
@@ -372,7 +385,7 @@ object ProtoTypes {
    *  [](args): resultType, where args are known to be typed
    */
   class FunProtoTyped(args: List[tpd.Tree], resultType: Type)(typer: Typer, isContextual: Boolean)(implicit ctx: Context) extends FunProto(args, resultType)(typer, isContextual)(ctx) {
-    override def unforcedTypedArgs: List[tpd.Tree] = args
+    override def unforcedTypedArgs(implicit ctx: Context): List[tpd.Tree] = args
     override def withContext(ctx: Context): FunProtoTyped = this
   }