Address reviewers comments.

Author: odersky

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

@@ -65,13 +65,12 @@ class TyperState(r: Reporter) extends DotClass with Showable {
   /** Optionally, if this is a mutable typerstate, it's creator state */
   def parent: Option[TyperState] = None
 
-  /** The closest ancestor of this typer state (including possible this typer state itself)
-   *  which is not yet committed.
+  /** The closest ancestor of this typer state (including possibly this typer state itself)
+   *  which is not yet committed, or which does not have a parent.
    */
-  def uncommittedAncestor: TyperState = parent match {
-    case Some(p) if p.isCommitted => p.uncommittedAncestor
-    case _ => this
-  }
+  def uncommittedAncestor: TyperState =
+    if (!isCommitted || !parent.isDefined) this
+    else parent.get.uncommittedAncestor
 
   /** Make type variable instances permanent by assigning to `inst` field if
    *  type variable instantiation cannot be retracted anymore. Then, remove

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

@@ -182,20 +182,6 @@ object ProtoTypes {
       if ((args eq this.args) && (resultType eq this.resultType) && (typer eq this.typer)) this
       else new FunProto(args, resultType, typer)
 
-    def argsAreTyped: Boolean = myTypedArgs.size == args.length
-
-    private def typedArg(arg: untpd.Tree, typerFn: untpd.Tree => Tree)(implicit ctx: Context): Tree = {
-      var targ = myTypedArg(arg)
-      if (targ == null) {
-        targ = typerFn(arg)
-        if (!ctx.reporter.hasPending) {
-          myTypedArg = myTypedArg.updated(arg, targ)
-          evalState = evalState.updated(arg, ctx.typerState)
-        }
-      }
-      targ
-    }
-
     /** Forget the types of any arguments that have been typed producing a constraint in a
      *  typer state that is not yet committed into the one of the current context `ctx`.
      *  This is necessary to avoid "orphan" PolyParams that are referred to from
@@ -206,27 +192,40 @@ object ProtoTypes {
     def allArgTypesAreCurrent()(implicit ctx: Context): Boolean = {
       evalState foreachBinding { (arg, tstate) =>
         if (tstate.uncommittedAncestor.constraint ne ctx.typerState.constraint) {
-          println(i"need to invalidate $arg / ${myTypedArg(arg)}, ${tstate.constraint}, current = ${ctx.typerState.constraint}")
+          typr.println(i"need to invalidate $arg / ${myTypedArg(arg)}, ${tstate.constraint}, current = ${ctx.typerState.constraint}")
           myTypedArg = myTypedArg.remove(arg)
           evalState = evalState.remove(arg)
         }
       }
       myTypedArg.size == args.length
     }
 
+    private def cacheTypedArg(arg: untpd.Tree, typerFn: untpd.Tree => Tree)(implicit ctx: Context): Tree = {
+      var targ = myTypedArg(arg)
+      if (targ == null) {
+        targ = typerFn(arg)
+        if (!ctx.reporter.hasPending) {
+          myTypedArg = myTypedArg.updated(arg, targ)
+          evalState = evalState.updated(arg, ctx.typerState)
+        }
+      }
+      targ
+    }
+
     /** The typed arguments. This takes any arguments already typed using
      *  `typedArg` into account.
      */
     def typedArgs: List[Tree] = {
-      if (!argsAreTyped) myTypedArgs = args.mapconserve(typedArg(_, typer.typed(_)))
+      if (myTypedArgs.size != args.length)
+        myTypedArgs = args.mapconserve(cacheTypedArg(_, typer.typed(_)))
       myTypedArgs
     }
 
     /** Type single argument and remember the unadapted result in `myTypedArg`.
      *  used to avoid repeated typings of trees when backtracking.
      */
     def typedArg(arg: untpd.Tree, formal: Type)(implicit ctx: Context): Tree = {
-      val targ = typedArg(arg, typer.typedUnadapted(_, formal))
+      val targ = cacheTypedArg(arg, typer.typedUnadapted(_, formal))
       typer.adapt(targ, formal, arg)
     }
 
@@ -262,7 +261,6 @@ 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 argsAreTyped = true
   }
 
   /** A prototype for implicitly inferred views: