Revert "Avoid exploring TyperState creations"

Author: allanrenucci

compiler/src/dotty/tools/dotc/Run.scala

@@ -49,7 +49,7 @@ class Run(comp: Compiler, ictx: Context) {
       .setOwner(defn.RootClass)
       .setTyper(new Typer)
       .addMode(Mode.ImplicitsEnabled)
-      .setTyperState(new TyperState(ctx.typerState))
+      .setTyperState(new MutableTyperState(ctx.typerState, ctx.typerState.reporter, isCommittable = true))
       .setFreshNames(new FreshNameCreator.Default)
     ctx.initialize()(start) // re-initialize the base context with start
     def addImport(ctx: Context, refFn: () => TermRef) =

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

@@ -459,9 +459,9 @@ object Contexts {
     def setCompilerCallback(callback: CompilerCallback): this.type = { this.compilerCallback = callback; this }
     def setSbtCallback(callback: AnalysisCallback): this.type = { this.sbtCallback = callback; this }
     def setTyperState(typerState: TyperState): this.type = { this.typerState = typerState; this }
-    def setReporter(reporter: Reporter): this.type = setTyperState(typerState.fresh().setReporter(reporter))
-    def setNewTyperState(): this.type = setTyperState(typerState.fresh().setCommittable(true))
-    def setExploreTyperState(): this.type = setTyperState(typerState.fresh().setCommittable(false))
+    def setReporter(reporter: Reporter): this.type = setTyperState(typerState.withReporter(reporter))
+    def setNewTyperState: this.type = setTyperState(typerState.fresh(isCommittable = true))
+    def setExploreTyperState: this.type = setTyperState(typerState.fresh(isCommittable = false))
     def setPrinterFn(printer: Context => Printer): this.type = { this.printerFn = printer; this }
     def setOwner(owner: Symbol): this.type = { assert(owner != NoSymbol); this.owner = owner; this }
     def setSettings(sstate: SettingsState): this.type = { this.sstate = sstate; this }
@@ -520,7 +520,7 @@ object Contexts {
     outer = NoContext
     period = InitialPeriod
     mode = Mode.None
-    typerState = new TyperState(null)
+    typerState = new TyperState(new ConsoleReporter())
     printerFn = new RefinedPrinter(_)
     owner = NoSymbol
     sstate = settings.defaultState

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

@@ -13,31 +13,18 @@ import config.Config
 import collection.mutable
 import java.lang.ref.WeakReference
 
-class TyperState(previous: TyperState /* | Null */) extends DotClass with Showable {
+class TyperState(r: Reporter) extends DotClass with Showable {
 
-  private var myReporter =
-    if (previous == null) new ConsoleReporter() else previous.reporter
+  /** The current reporter */
+  def reporter = r
 
-  def reporter: Reporter = myReporter
+  /** The current constraint set */
+  def constraint: Constraint =
+    new OrderingConstraint(SimpleMap.Empty, SimpleMap.Empty, SimpleMap.Empty)
+  def constraint_=(c: Constraint)(implicit ctx: Context): Unit = {}
 
-  /** A fresh type state with the same constraint as this one and the given reporter */
-  def setReporter(reporter: Reporter): this.type = { myReporter = reporter; this }
-
-  private var myConstraint: Constraint =
-    if (previous == null) new OrderingConstraint(SimpleMap.Empty, SimpleMap.Empty, SimpleMap.Empty)
-    else previous.constraint
-
-  def constraint = myConstraint
-  def constraint_=(c: Constraint)(implicit ctx: Context) = {
-    if (Config.debugCheckConstraintsClosed && isGlobalCommittable) c.checkClosed()
-    myConstraint = c
-  }
-
-  private val previousConstraint =
-    if (previous == null) constraint else previous.constraint
-
-  private var myEphemeral: Boolean =
-    if (previous == null) false else previous.ephemeral
+  /** The uninstantiated variables */
+  def uninstVars = constraint.uninstVars
 
   /** The ephemeral flag is set as a side effect if an operation accesses
    *  the underlying type of a type variable. The reason we need this flag is
@@ -46,26 +33,8 @@ class TyperState(previous: TyperState /* | Null */) extends DotClass with Showab
    *  check the ephemeral flag; If the flag is set during an operation, the result
    *  of that operation should not be cached.
    */
-  def ephemeral = myEphemeral
-  def ephemeral_=(x: Boolean): Unit = { myEphemeral = x }
-
-  private var myIsCommittable = true
-
-  def isCommittable = myIsCommittable
-
-  def setCommittable(committable: Boolean): this.type = { this.myIsCommittable = committable; this }
-
-  def isGlobalCommittable: Boolean =
-    isCommittable && (previous == null || previous.isGlobalCommittable)
-
-  private var isCommitted = false
-
-  /** A fresh typer state with the same constraint as this one. */
-  def fresh(): TyperState =
-    new TyperState(this).setReporter(new StoreReporter(reporter)).setCommittable(isCommittable)
-
-  /** The uninstantiated variables */
-  def uninstVars = constraint.uninstVars
+  def ephemeral: Boolean = false
+  def ephemeral_=(x: Boolean): Unit = ()
 
   /** Gives for each instantiated type var that does not yet have its `inst` field
    *  set, the instance value stored in the constraint. Storing instances in constraints
@@ -80,36 +49,76 @@ class TyperState(previous: TyperState /* | Null */) extends DotClass with Showab
     case tp => tp
   }
 
+  /** A fresh typer state with the same constraint as this one.
+   *  @param isCommittable  The constraint can be committed to an enclosing context.
+   */
+  def fresh(isCommittable: Boolean): TyperState = this
+
+  /** A fresh type state with the same constraint as this one and the given reporter */
+  def withReporter(reporter: Reporter) = new TyperState(reporter)
+
+  /** Commit state so that it gets propagated to enclosing context */
+  def commit()(implicit ctx: Context): Unit = unsupported("commit")
+
   /** 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 =
-    if (isCommitted) previous.uncommittedAncestor else this
+  def uncommittedAncestor: TyperState = this
 
-  private var testReporter: StoreReporter = null
-
-  /** Test using `op`, restoring typerState to previous state afterwards */
-  def test(op: => Boolean): Boolean = {
-    val savedReporter = myReporter
-    val savedConstraint = myConstraint
-    val savedCommittable = myIsCommittable
-    val savedCommitted = isCommitted
-    myIsCommittable = false
-    myReporter =
-      if (testReporter == null) new StoreReporter(reporter)
-      else {
-        testReporter.reset()
-        testReporter
-      }
-    try op
-    finally {
-      myReporter = savedReporter
-      myConstraint = savedConstraint
-      myIsCommittable = savedCommittable
-      isCommitted = savedCommitted
-    }
+  /** 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.
+   */
+  def gc()(implicit ctx: Context): Unit = ()
+
+  /** Is it allowed to commit this state? */
+  def isCommittable: Boolean = false
+
+  /** Can this state be transitively committed until the top-level? */
+  def isGlobalCommittable: Boolean = false
+
+  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)
+extends TyperState(r) {
+
+  private var myReporter = r
+
+  override def reporter = myReporter
+
+  private val previousConstraint = previous.constraint
+  private var myConstraint: Constraint = previousConstraint
+
+  override def constraint = myConstraint
+  override def constraint_=(c: Constraint)(implicit ctx: Context) = {
+    if (Config.debugCheckConstraintsClosed && isGlobalCommittable) c.checkClosed()
+    myConstraint = c
   }
 
+  private var myEphemeral: Boolean = previous.ephemeral
+
+  override def ephemeral = myEphemeral
+  override def ephemeral_=(x: Boolean): Unit = { myEphemeral = x }
+
+  override def fresh(isCommittable: Boolean): TyperState =
+    new MutableTyperState(this, new StoreReporter(reporter), isCommittable)
+
+  override def withReporter(reporter: Reporter) =
+    new MutableTyperState(this, reporter, isCommittable)
+
+  override val isGlobalCommittable =
+    isCommittable &&
+    (!previous.isInstanceOf[MutableTyperState] || previous.isGlobalCommittable)
+
+  private var isCommitted = false
+
+  override def uncommittedAncestor: TyperState =
+    if (isCommitted) previous.uncommittedAncestor else this
+
   /** 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
@@ -128,7 +137,7 @@ class TyperState(previous: TyperState /* | Null */) extends DotClass with Showab
    * isApplicableSafe but also for (e.g. erased-lubs.scala) as well as
    * many parts of dotty itself.
    */
-  def commit()(implicit ctx: Context) = {
+  override def commit()(implicit ctx: Context) = {
     val targetState = ctx.typerState
     assert(isCommittable)
     targetState.constraint =
@@ -143,11 +152,7 @@ class TyperState(previous: TyperState /* | Null */) extends DotClass with Showab
     isCommitted = true
   }
 
-  /** 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.
-   */
-  def gc()(implicit ctx: Context): Unit = {
+  override def gc()(implicit ctx: Context): Unit = {
     val toCollect = new mutable.ListBuffer[TypeLambda]
     constraint foreachTypeVar { tvar =>
       if (!tvar.inst.exists) {
@@ -165,5 +170,6 @@ class TyperState(previous: TyperState /* | Null */) extends DotClass with Showab
 
   override def toText(printer: Printer): Text = constraint.toText(printer)
 
-  def hashesStr: String = hashCode.toString + " -> " + previous.hashesStr
+  override def hashesStr: String = hashCode.toString + " -> " + previous.hashesStr
+
 }

compiler/src/dotty/tools/dotc/reporting/StoreReporter.scala

@@ -22,8 +22,6 @@ class StoreReporter(outer: Reporter) extends Reporter {
 
   private var infos: mutable.ListBuffer[MessageContainer] = null
 
-  def reset() = infos = null
-
   def doReport(m: MessageContainer)(implicit ctx: Context): Unit = {
     typr.println(s">>>> StoredError: ${m.message}") // !!! DEBUG
     if (infos == null) infos = new mutable.ListBuffer

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

@@ -847,7 +847,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     def followTypeAlias(tree: untpd.Tree): untpd.Tree = {
       tree match {
         case tree: untpd.RefTree =>
-          val nestedCtx = ctx.fresh.setNewTyperState()
+          val nestedCtx = ctx.fresh.setNewTyperState
           val ttree =
             typedType(untpd.rename(tree, tree.name.toTypeName))(nestedCtx)
           ttree.tpe match {
@@ -1002,20 +1002,26 @@ 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 =
-    ctx.typerState.test(new ApplicableToTrees(methRef, targs, args, resultType).success)
+  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
+  }
 
   /** 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 =
-    ctx.typerState.test(new ApplicableToTreesDirectly(methRef, targs, args, resultType).success)
+  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
+  }
 
   /** 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 =
-    ctx.typerState.test(new ApplicableToTypes(methRef, args, resultType).success)
+  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
+  }
 
   /** Is given type applicable to type arguments `targs` and argument trees `args`,
    *  possibly after inserting an `apply`?
@@ -1096,7 +1102,12 @@ 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)
-            ctx.typerState.test(isAsSpecificValueType(tp1, constrained(tp2).resultType))
+            val nestedCtx = ctx.fresh.setExploreTyperState
+
+            {
+              implicit val ctx = nestedCtx
+              isAsSpecificValueType(tp1, constrained(tp2).resultType)
+            }
           case _ => // (3b)
             isAsSpecificValueType(tp1, tp2)
         }
@@ -1246,20 +1257,22 @@ 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) = 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
+    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
+      }
     }
 
     var found = resolveOverloaded(alts, pt, Nil)(ctx.retractMode(Mode.ImplicitsEnabled))