Fix #4466: Update contexts of FunProto when something else is tried

Type inference does backtracking over several possibilities, with fresh
contexts for each branch. If a FunProto is kept from one branch to the next
we have to make sure that it uses the right context in the new branch.

Author: odersky

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

@@ -1593,6 +1593,7 @@ object Types {
     def isMatchedBy(tp: Type)(implicit ctx: Context): Boolean
     def fold[T](x: T, ta: TypeAccumulator[T])(implicit ctx: Context): T
     def map(tm: TypeMap)(implicit ctx: Context): ProtoType
+    def withContext(ctx: Context): ProtoType = this
   }
 
   /** Implementations of this trait cache the results of `narrow`. */

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

@@ -216,15 +216,15 @@ object ProtoTypes {
    */
   case class FunProto(args: List[untpd.Tree], resType: Type, typer: Typer)(implicit ctx: Context)
   extends UncachedGroundType with ApplyingProto {
-    private[this] var myTypedArgs: List[Tree] = Nil
+    private var myTypedArgs: List[Tree] = Nil
 
     override def resultType(implicit ctx: Context) = resType
 
     /** A map in which typed arguments can be stored to be later integrated in `typedArgs`. */
-    private[this] var myTypedArg: SimpleIdentityMap[untpd.Tree, Tree] = SimpleIdentityMap.Empty
+    private var myTypedArg: SimpleIdentityMap[untpd.Tree, Tree] = SimpleIdentityMap.Empty
 
     /** A map recording the typer states and constraints in which arguments stored in myTypedArg were typed */
-    private[this] var evalState: SimpleIdentityMap[untpd.Tree, (TyperState, Constraint)] = SimpleIdentityMap.Empty
+    private var evalState: SimpleIdentityMap[untpd.Tree, (TyperState, Constraint)] = SimpleIdentityMap.Empty
 
     def isMatchedBy(tp: Type)(implicit ctx: Context) =
       typer.isApplicable(tp, Nil, unforcedTypedArgs, resultType)
@@ -308,7 +308,7 @@ object ProtoTypes {
     def typeOfArg(arg: untpd.Tree)(implicit ctx: Context): Type =
       myTypedArg(arg).tpe
 
-    private[this] var myTupled: Type = NoType
+    private var myTupled: Type = NoType
 
     /** The same proto-type but with all arguments combined in a single tuple */
     def tupled: FunProto = myTupled match {
@@ -323,7 +323,7 @@ object ProtoTypes {
     def isTupled: Boolean = myTupled.isInstanceOf[FunProto]
 
     /** If true, the application of this prototype was canceled. */
-    private[this] var toDrop: Boolean = false
+    private var toDrop: Boolean = false
 
     /** Cancel the application of this prototype. This can happen for a nullary
      *  application `f()` if `f` refers to a symbol that exists both in parameterless
@@ -347,6 +347,18 @@ object ProtoTypes {
       ta(ta.foldOver(x, typedArgs.tpes), resultType)
 
     override def deepenProto(implicit ctx: Context) = derivedFunProto(args, resultType.deepenProto, typer)
+
+    override def withContext(newCtx: Context) =
+      if (newCtx `eq` ctx) this
+      else {
+        val result = new FunProto(args, resType, typer)(newCtx)
+        result.myTypedArgs = myTypedArgs
+        result.myTypedArg = myTypedArg
+        result.evalState = evalState
+        result.myTupled = myTupled
+        result.toDrop = toDrop
+        result
+      }
   }
 
 
@@ -356,6 +368,7 @@ object ProtoTypes {
    */
   class FunProtoTyped(args: List[tpd.Tree], resultType: Type, typer: Typer)(implicit ctx: Context) extends FunProto(args, resultType, typer)(ctx) {
     override def typedArgs = args
+    override def withContext(ctx: Context) = this
   }
 
   /** A prototype for implicitly inferred views:

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

@@ -2043,14 +2043,15 @@ class Typer extends Namer
     }
 
     def tryApply(implicit ctx: Context) = {
-      val sel = typedSelect(untpd.Select(untpd.TypedSplice(tree), nme.apply), pt)
+      val pt1 = pt.withContext(ctx)
+      val sel = typedSelect(untpd.Select(untpd.TypedSplice(tree), nme.apply), pt1)
       sel.pushAttachment(InsertedApply, ())
       if (sel.tpe.isError) sel
-      else try adapt(simplify(sel, pt, locked), pt, locked) finally sel.removeAttachment(InsertedApply)
+      else try adapt(simplify(sel, pt1, locked), pt1, locked) finally sel.removeAttachment(InsertedApply)
     }
 
     def tryImplicit(fallBack: => Tree) =
-      tryInsertImplicitOnQualifier(tree, pt, locked).getOrElse(fallBack)
+      tryInsertImplicitOnQualifier(tree, pt.withContext(ctx), locked).getOrElse(fallBack)
 
     pt match {
       case pt @ FunProto(Nil, _, _)

tests/pos/i4466a.scala

@@ -0,0 +1,11 @@
+class Foo {
+  def apply(bar: Bar[Int]): Unit = ()
+  def apply(i: Int): Unit = ()
+}
+
+class Bar[X](x: X)
+
+class Main {
+  val foo = new Foo
+  foo(new Bar(0))
+}

tests/pos/i4466b.scala

@@ -0,0 +1,9 @@
+object Foo {
+  case class Bar(map: Map[String, String])
+
+  object Bar {
+    def apply(str: String): Bar = ???
+  }
+
+  Bar(Map("A" -> "B"))
+}