Avoid exploring TyperState creations

Dotty bootstrap (from dotc directory) has 5924910 context creations.
This commit brings that number down to 4307795. It also reduces the
number of TyperStates created from 2'059'126 to 308'732.

Author: odersky

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

@@ -73,17 +73,21 @@ class TyperState(r: Reporter) extends DotClass with Showable {
 
   /** Is it allowed to commit this state? */
   def isCommittable: Boolean = false
+  def isCommittable_=(b: Boolean) = ()
 
   /** Can this state be transitively committed until the top-level? */
   def isGlobalCommittable: Boolean = false
 
+  /** Test using `op`, restoring typerState to previous state afterwards */
+  def test(op: => Boolean): Boolean = op
+
   override def toText(printer: Printer): Text = "ImmutableTyperState"
 
   /** A string showing the hashes of all nested mutable typerstates */
   def hashesStr: String = ""
 }
 
-class MutableTyperState(previous: TyperState, r: Reporter, override val isCommittable: Boolean)
+class MutableTyperState(previous: TyperState, r: Reporter, override var isCommittable: Boolean)
 extends TyperState(r) {
 
   private var myReporter = r
@@ -119,6 +123,21 @@ extends TyperState(r) {
   override def uncommittedAncestor: TyperState =
     if (isCommitted) previous.uncommittedAncestor else this
 
+  override def test(op: => Boolean): Boolean = {
+    val savedReporter = myReporter
+    val savedConstraint = myConstraint
+    val savedCommitted = isCommitted
+    val savedCommittable = isCommittable
+    isCommittable = false
+    try op
+    finally {
+      myReporter = savedReporter
+      myConstraint = savedConstraint
+      isCommitted = savedCommitted
+      isCommittable = savedCommittable
+    }
+  }
+
   /** Commit typer state so that its information is copied into current typer state
    *  In addition (1) the owning state of undetermined or temporarily instantiated
    *  type variables changes from this typer state to the current one. (2) Variables

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

@@ -1002,26 +1002,20 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
   /** Is given method reference applicable to type arguments `targs` and argument trees `args`?
    *  @param  resultType   The expected result type of the application
    */
-  def isApplicable(methRef: TermRef, targs: List[Type], args: List[Tree], resultType: Type)(implicit ctx: Context): Boolean = {
-    val nestedContext = ctx.fresh.setExploreTyperState
-    new ApplicableToTrees(methRef, targs, args, resultType)(nestedContext).success
-  }
+  def isApplicable(methRef: TermRef, targs: List[Type], args: List[Tree], resultType: Type)(implicit ctx: Context): Boolean =
+    ctx.typerState.test(new ApplicableToTrees(methRef, targs, args, resultType).success)
 
   /** Is given method reference applicable to type arguments `targs` and argument trees `args` without inferring views?
     *  @param  resultType   The expected result type of the application
     */
-  def isDirectlyApplicable(methRef: TermRef, targs: List[Type], args: List[Tree], resultType: Type)(implicit ctx: Context): Boolean = {
-    val nestedContext = ctx.fresh.setExploreTyperState
-    new ApplicableToTreesDirectly(methRef, targs, args, resultType)(nestedContext).success
-  }
+  def isDirectlyApplicable(methRef: TermRef, targs: List[Type], args: List[Tree], resultType: Type)(implicit ctx: Context): Boolean =
+    ctx.typerState.test(new ApplicableToTreesDirectly(methRef, targs, args, resultType).success)
 
   /** Is given method reference applicable to argument types `args`?
    *  @param  resultType   The expected result type of the application
    */
-  def isApplicable(methRef: TermRef, args: List[Type], resultType: Type)(implicit ctx: Context): Boolean = {
-    val nestedContext = ctx.fresh.setExploreTyperState
-    new ApplicableToTypes(methRef, args, resultType)(nestedContext).success
-  }
+  def isApplicable(methRef: TermRef, args: List[Type], resultType: Type)(implicit ctx: Context): Boolean =
+    ctx.typerState.test(new ApplicableToTypes(methRef, args, resultType).success)
 
   /** Is given type applicable to type arguments `targs` and argument trees `args`,
    *  possibly after inserting an `apply`?
@@ -1102,12 +1096,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
           case tp2: MethodType => true // (3a)
           case tp2: PolyType if tp2.resultType.isInstanceOf[MethodType] => true // (3a)
           case tp2: PolyType => // (3b)
-            val nestedCtx = ctx.fresh.setExploreTyperState
-
-            {
-              implicit val ctx = nestedCtx
-              isAsSpecificValueType(tp1, constrained(tp2).resultType)
-            }
+            ctx.typerState.test(isAsSpecificValueType(tp1, constrained(tp2).resultType))
           case _ => // (3b)
             isAsSpecificValueType(tp1, tp2)
         }
@@ -1257,22 +1246,20 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
      *  probability of pruning the search. result type comparisons are neither cheap nor
      *  do they prune much, on average.
      */
-    def adaptByResult(chosen: TermRef) = {
-      def nestedCtx = ctx.fresh.setExploreTyperState
-      pt match {
-        case pt: FunProto if !resultConforms(chosen, pt.resultType)(nestedCtx) =>
-          alts.filter(alt =>
-            (alt ne chosen) && resultConforms(alt, pt.resultType)(nestedCtx)) match {
-            case Nil => chosen
-            case alt2 :: Nil => alt2
-            case alts2 =>
-              resolveOverloaded(alts2, pt) match {
-                case alt2 :: Nil => alt2
-                case _ => chosen
-              }
-          }
-        case _ => chosen
-      }
+    def adaptByResult(chosen: TermRef) = pt match {
+      case pt: FunProto if !ctx.typerState.test(resultConforms(chosen, pt.resultType)) =>
+        val conformingAlts = alts.filter(alt =>
+          (alt ne chosen) && ctx.typerState.test(resultConforms(alt, pt.resultType)))
+        conformingAlts match {
+          case Nil => chosen
+          case alt2 :: Nil => alt2
+          case alts2 =>
+            resolveOverloaded(alts2, pt) match {
+              case alt2 :: Nil => alt2
+              case _ => chosen
+            }
+        }
+      case _ => chosen
     }
 
     var found = resolveOverloaded(alts, pt, Nil)(ctx.retractMode(Mode.ImplicitsEnabled))

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

@@ -67,15 +67,15 @@ object Implicits {
           case mt: MethodType =>
             mt.isImplicit ||
             mt.paramInfos.length != 1 ||
-            !(argType relaxed_<:< mt.paramInfos.head)(ctx.fresh.setExploreTyperState)
+            !ctx.typerState.test(argType relaxed_<:< mt.paramInfos.head)
           case poly: PolyType =>
             // We do not need to call ProtoTypes#constrained on `poly` because
             // `refMatches` is always called with mode TypevarsMissContext enabled.
             poly.resultType match {
               case mt: MethodType =>
                 mt.isImplicit ||
                 mt.paramInfos.length != 1 ||
-                !(argType relaxed_<:< wildApprox(mt.paramInfos.head, null, Set.empty)(ctx.fresh.setExploreTyperState))
+                !ctx.typerState.test(argType relaxed_<:< wildApprox(mt.paramInfos.head, null, Set.empty))
               case rtp =>
                 discardForView(wildApprox(rtp, null, Set.empty), argType)
             }
@@ -132,8 +132,12 @@ object Implicits {
       }
 
       if (refs.isEmpty) Nil
-      else refs.filter(refMatches(_)(ctx.fresh.addMode(Mode.TypevarsMissContext).setExploreTyperState)) // create a defensive copy of ctx to avoid constraint pollution
-               .map(Candidate(_, level))
+      else {
+        val nestedCtx = ctx.fresh.addMode(Mode.TypevarsMissContext)
+        refs
+          .filter(ref => nestedCtx.typerState.test(refMatches(ref)(nestedCtx)))
+          .map(Candidate(_, level))
+      }
     }
   }
 
@@ -505,6 +509,7 @@ trait Implicits { self: Typer =>
        || inferView(dummyTreeOfType(from), to)
             (ctx.fresh.addMode(Mode.ImplicitExploration).setExploreTyperState)
             .isInstanceOf[SearchSuccess]
+          // TODO: investigate why we can't TyperState#test here
        )
     )
 
@@ -576,7 +581,7 @@ trait Implicits { self: Typer =>
       formal.argTypes match {
         case args @ (arg1 :: arg2 :: Nil)
         if !ctx.featureEnabled(defn.LanguageModuleClass, nme.strictEquality) &&
-           validEqAnyArgs(arg1, arg2)(ctx.fresh.setExploreTyperState) =>
+           ctx.typerState.test(validEqAnyArgs(arg1, arg2)) =>
           ref(defn.Eq_eqAny).appliedToTypes(args).withPos(pos)
         case _ =>
           EmptyTree
@@ -822,7 +827,7 @@ trait Implicits { self: Typer =>
               if (ctx.mode.is(Mode.ImplicitExploration) || isCoherent) best :: Nil
               else {
                 val newPending = pending1.filter(cand1 =>
-                  isAsGood(cand1.ref, best.ref, cand1.level, best.level)(nestedContext.setExploreTyperState))
+                  ctx.typerState.test(isAsGood(cand1.ref, best.ref, cand1.level, best.level)(nestedContext)))
                 rankImplicits(newPending, best :: acc)
               }
           }
@@ -851,7 +856,8 @@ trait Implicits { self: Typer =>
       /** Convert a (possibly empty) list of search successes into a single search result */
       def condense(hits: List[SearchSuccess]): SearchResult = hits match {
         case best :: alts =>
-          alts find (alt => isAsGood(alt.ref, best.ref, alt.level, best.level)(ctx.fresh.setExploreTyperState)) match {
+          alts.find(alt =>
+            ctx.typerState.test(isAsGood(alt.ref, best.ref, alt.level, best.level))) match {
             case Some(alt) =>
               typr.println(i"ambiguous implicits for $pt: ${best.ref} @ ${best.level}, ${alt.ref} @ ${alt.level}")
             /* !!! DEBUG

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

@@ -1972,7 +1972,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       val constraint = ctx.typerState.constraint
       def inst(tp: Type): Type = tp match {
         case TypeBounds(lo, hi)
-        if (lo eq hi) || (hi <:< lo)(ctx.fresh.setExploreTyperState) =>
+        if (lo eq hi) || ctx.typerState.test(hi <:< lo) =>
           inst(lo)
         case tp: TypeParamRef =>
           constraint.typeVarOfParam(tp).orElse(tp)