Store message expressions of ErrorTypes in separate map.

Message expressions usually capture contexts, which can cause space leaks
if an error type is stored in a retained tree.

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -75,7 +75,7 @@ object desugar {
             else {
               def msg =
                 s"no matching symbol for ${tp.symbol.showLocated} in ${defctx.owner} / ${defctx.effectiveScope}"
-              if (ctx.reporter.errorsReported) new ErrorType(msg)
+              if (ctx.reporter.errorsReported) ErrorType(msg)
               else throw new java.lang.Error(msg)
             }
           case _ =>

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

@@ -24,6 +24,7 @@ import Implicits.ContextualImplicits
 import config.Settings._
 import config.Config
 import reporting._
+import reporting.diagnostic.Message
 import collection.mutable
 import collection.immutable.BitSet
 import printing._
@@ -636,6 +637,12 @@ object Contexts {
      */
     private[dotty] var unsafeNonvariant: RunId = NoRunId
 
+    /** A map from ErrorType to associated message computation. We use this map
+     *  instead of storing message computations directly in ErrorTypes in order
+     *  to avoid space leaks - the message computation usually captures a context.
+     */
+    private[core] val errorTypeMsg = mutable.Map[ErrorType, () => Message]()
+
     // Phases state
 
     private[core] var phasesPlan: List[List[Phase]] = _
@@ -662,6 +669,7 @@ object Contexts {
 
     def reset() = {
       for ((_, set) <- uniqueSets) set.clear()
+      errorTypeMsg.clear()
     }
 
     // Test that access is single threaded

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

@@ -1904,7 +1904,7 @@ object SymDenotations {
         case denot: ClassDenotation =>
           ClassInfo(denot.owner.thisType, denot.classSymbol, Nil, EmptyScope)
         case _ =>
-          new ErrorType(errMsg)
+          ErrorType(errMsg)
       }
       denot.privateWithin = NoSymbol
     }

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

@@ -298,7 +298,7 @@ trait Symbols { this: Context =>
   def newSkolem(tp: Type) = newSymbol(defn.RootClass, nme.SKOLEM, SyntheticArtifact | Permanent, tp)
 
   def newErrorSymbol(owner: Symbol, name: Name, msg: => Message) = {
-    val errType = new ErrorType(msg)
+    val errType = ErrorType(msg)
     newSymbol(owner, name, SyntheticArtifact,
         if (name.isTypeName) TypeAlias(errType) else errType)
   }

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

@@ -3553,11 +3553,24 @@ object Types {
    */
   abstract class FlexType extends UncachedGroundType with ValueType
 
-  class ErrorType(_msg: => Message) extends FlexType {
-    def msg = _msg
+  class ErrorType private[Types] () extends FlexType {
+    def msg(implicit ctx: Context): Message =
+      ctx.errorTypeMsg.get(this) match {
+        case Some(msgFun) => msgFun()
+        case None => "error message from previous run no longer available"
+      }
+  }
+  object ErrorType {
+    def apply(msg: => Message)(implicit ctx: Context): ErrorType = {
+      val et = new ErrorType
+      ctx.base.errorTypeMsg(et) = () => msg
+      et
+    }
   }
 
-  object UnspecifiedErrorType extends ErrorType("unspecified error")
+  object UnspecifiedErrorType extends ErrorType() {
+    override def msg(implicit ctx: Context): Message = "unspecified error"
+  }
 
   /* Type used to track Select nodes that could not resolve a member and their qualifier is a scala.Dynamic. */
   object TryDynamicCallType extends FlexType

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

@@ -23,7 +23,7 @@ object ErrorReporting {
 
   def errorType(msg: => Message, pos: Position)(implicit ctx: Context): ErrorType = {
     ctx.error(msg, pos)
-    new ErrorType(msg)
+    ErrorType(msg)
   }
 
   def cyclicErrorMsg(ex: CyclicReference)(implicit ctx: Context) = {