Accumulate errors in effect checking

Author: liufengyun

compiler/src/dotty/tools/dotc/transform/init/Checking.scala

@@ -15,7 +15,7 @@ import util.NoSourcePosition
 import reporting.trace
 import config.Printers.init
 
-import Effects._, Potentials._, Summary._, Util._
+import Effects._, Potentials._, Summary._, Util._, Errors._
 
 object Checking {
   /** The checking state
@@ -41,26 +41,6 @@ object Checking {
       visited += eff
       copy(path = this.path :+ eff.source)
     }
-
-    def trace(implicit state: State): String = {
-      var indentCount = 0
-      var last = ""
-      val sb = new StringBuilder
-      this.path.foreach { tree =>
-        indentCount += 1
-        val pos = tree.sourcePos
-        val line = "[ " + pos.source.file.name + ":" + (pos.line + 1) + " ]"
-        if (last != line)
-          sb.append(
-            if (pos.source.exists)
-              i"${ " " * indentCount }-> ${pos.lineContent.trim}\t$line\n"
-            else
-              i"${tree.show}\n"
-          )
-        last = line
-      }
-      sb.toString
-    }
   }
 
   private implicit def theEnv(implicit state: State): Env = state.env
@@ -158,66 +138,36 @@ object Checking {
     }
   }
 
-  private def nonInitError(field: Symbol)(implicit state: State) = {
-    traceIndented("initialized: " + state.fieldsInited, init)
-
-    // should issue error, use warning so that it will continue compile subprojects
-    theCtx.warning(
-      "Access non-initialized field " + field.show +
-      ". Calling trace:\n" + state.trace,
-      field.sourcePos
-    )
-  }
-
-  private def externalCallError(sym: Symbol, source: Tree)(implicit state: State) =
-    theCtx.warning(
-      "Calling the external method " + sym.show +
-      " may cause initialization errors" +
-      ". Calling trace:\n" + state.trace,
-      source.sourcePos
-    )
-
   private def checkEffectsIn(effs: Effects, cls: ClassSymbol)(implicit state: State): Unit = {
     val rebased = Effects.asSeenFrom(effs, ThisRef(state.thisClass)(null), cls, Potentials.empty)
     rebased.foreach { check(_) }
   }
 
-  private def check(eff: Effect)(implicit state: State): Unit =
-    if (!state.visited.contains(eff)) traceOp("checking effect " + eff.show, init) {
+  private def check(eff: Effect)(implicit state: State): Errors =
+    if (state.visited.contains(eff)) Errors.empty else trace("checking effect " + eff.show, init, errs => Errors.show(errs.asInstanceOf[Errors])) {
       implicit val state2: State = state.withVisited(eff)
 
       eff match {
         case Promote(pot) =>
           pot match {
-            case ThisRef(cls) =>
+            case pot @ ThisRef(cls) =>
               assert(cls == state.thisClass, "unexpected potential " + pot.show)
-
-              theCtx.warning(
-                "Promote `this` to be initialized while it is not. Calling trace:\n" + state.trace,
-                eff.source.sourcePos
-              )
+              PromoteThis(pot, eff.source, state.path).toErrors
 
             case _: Cold =>
-              theCtx.warning(
-                "Promoting the value " + eff.source.show + " to be initialized while it is under initialization" +
-                ". Calling trace:\n" + state.trace,
-                eff.source.sourcePos
-              )
+              PromoteCold(eff.source, state.path).toErrors
 
-            case Warm(cls, outer) =>
-              theCtx.warning(
-                "Promoting the value under initialization to be initialized: " + pot.source.show +
-                ". Calling trace:\n" + state.trace,
-                eff.source.sourcePos
-              )
+            case pot @ Warm(cls, outer) =>
+              PromoteWarm(pot, eff.source, state.path).toErrors
 
             case Fun(pots, effs) =>
-              effs.foreach { check(_) }
-              pots.foreach { pot => check(Promote(pot)(eff.source)) }
+              val errs1 = effs.flatMap { check(_) }
+              val errs2 = pots.flatMap { pot => check(Promote(pot)(eff.source)) }
+              UnsafePromotion(pot, eff.source, state.path, errs1 ++ errs2).toErrors
 
             case pot =>
               val pots = expand(pot)
-              pots.foreach { pot => check(Promote(pot)(eff.source)) }
+              pots.flatMap { pot => check(Promote(pot)(eff.source)) }
           }
 
         case FieldAccess(pot, field) =>
@@ -228,33 +178,32 @@ object Checking {
 
               val target = resolve(cls, field)
               if (target.is(Flags.Lazy)) check(MethodCall(pot, target)(eff.source))
-              else if (!state.fieldsInited.contains(target)) nonInitError(target)
+              else if (!state.fieldsInited.contains(target)) AccessNonInit(target, state.path).toErrors
+              else Errors.empty
 
             case SuperRef(ThisRef(cls), supercls) =>
               assert(cls == state.thisClass, "unexpected potential " + pot.show)
 
               val target = resolveSuper(cls, supercls, field)
               if (target.is(Flags.Lazy)) check(MethodCall(pot, target)(eff.source))
-              else if (!state.fieldsInited.contains(target)) nonInitError(target)
+              else if (!state.fieldsInited.contains(target)) AccessNonInit(target, state.path).toErrors
+              else Errors.empty
 
             case Warm(cls, outer) =>
               // all fields of warm values are initialized
               val target = resolve(cls, field)
               if (target.is(Flags.Lazy)) check(MethodCall(pot, target)(eff.source))
+              else Errors.empty
 
             case _: Cold =>
-              theCtx.warning(
-                "Access field " + eff.source.show + " on a known value under initialization" +
-                ". Calling trace:\n" + state.trace,
-                eff.source.sourcePos
-              )
+              AccessCold(field, eff.source, state.path).toErrors
 
             case Fun(pots, effs) =>
               throw new Exception("Unexpected effect " + eff.show)
 
             case pot =>
               val pots = expand(pot)
-              pots.foreach { pot => check(FieldAccess(pot, field)(eff.source)) }
+              pots.flatMap { pot => check(FieldAccess(pot, field)(eff.source)) }
           }
 
         case MethodCall(pot, sym) =>
@@ -267,9 +216,9 @@ object Checking {
                 check(FieldAccess(pot, target)(eff.source))
               else if (target.isInternal) {
                 val effs = thisRef.effectsOf(target)
-                effs.foreach { check(_) }
+                effs.flatMap { check(_) }
               }
-              else externalCallError(target, eff.source)
+              else CallUnknown(target, eff.source, state.path).toErrors
 
             case SuperRef(thisRef @ ThisRef(cls), supercls) =>
               assert(cls == state.thisClass, "unexpected potential " + pot.show)
@@ -279,37 +228,32 @@ object Checking {
                 check(FieldAccess(pot, target)(eff.source))
               else if (target.isInternal) {
                 val effs = thisRef.effectsOf(target)
-                effs.foreach { check(_) }
+                effs.flatMap { check(_) }
               }
-              else externalCallError(target, eff.source)
+              else CallUnknown(target, eff.source, state.path).toErrors
 
             case warm @ Warm(cls, outer) =>
               val target = resolve(cls, sym)
 
               if (target.isInternal) {
                 val effs = warm.effectsOf(target)
-                effs.foreach { check(_) }
+                effs.flatMap { check(_) }
               }
-              else if (!sym.isConstructor) externalCallError(target, eff.source)
+              else if (!sym.isConstructor) CallUnknown(target, eff.source, state.path).toErrors
+              else Errors.empty
 
             case _: Cold =>
-              theCtx.warning(
-                "Call method " + eff.source.show + " on a cold value" +
-                ". Calling trace:\n" + state.trace,
-                eff.source.sourcePos
-              )
+              CallCold(sym, eff.source, state.path).toErrors
 
             case Fun(pots, effs) =>
               // TODO: assertion might be false, due to SAM
-              if (sym.name.toString == "apply") {
-                effs.foreach { check(_) }
-                pots.foreach { pot => check(Promote(pot)(eff.source)) }
-              }
+              if (sym.name.toString == "apply") effs.flatMap { check(_) }
+              else Errors.empty
               // curried, tupled, toString are harmless
 
             case pot =>
               val pots = expand(pot)
-              pots.foreach { pot =>
+              pots.flatMap { pot =>
                 check(MethodCall(pot, sym)(eff.source))
               }
           }

compiler/src/dotty/tools/dotc/transform/init/Errors.scala

@@ -14,10 +14,15 @@ object Errors {
   type Errors = Set[Error]
   val empty: Errors = Set.empty
 
+  def show(errs: Errors)(implicit ctx: Context): String =
+    errs.map(_.show).mkString(", ")
+
   sealed trait Error {
     def trace: Vector[Tree]
     def report(implicit ctx: Context): Unit
-    def message(implicit ctx: Context): String
+    def show(implicit ctx: Context): String
+
+    def toErrors: Errors = Set(this)
 
     def stacktrace(implicit ctx: Context): String = {
       var indentCount = 0
@@ -42,45 +47,54 @@ object Errors {
 
   /** Access non-initialized field */
   case class AccessNonInit(field: Symbol, trace: Vector[Tree]) extends Error {
-    def message(implicit ctx: Context): String =
+    def show(implicit ctx: Context): String =
       "Access non-initialized field " + field.show + ". Calling trace:\n" + stacktrace
 
     def report(implicit ctx: Context): Unit = ???
   }
 
   /** Promote `this` under initialization to fully-initialized */
   case class PromoteThis(pot: ThisRef, source: Tree, trace: Vector[Tree]) extends Error {
-    def message(implicit ctx: Context): String = "Promote `this` to be initialized while it is not. Calling trace:\n" + stacktrace
+    def show(implicit ctx: Context): String = "Promote `this` to be initialized while it is not. Calling trace:\n" + stacktrace
+    def report(implicit ctx: Context): Unit = ???
+  }
+
+  /** Promote `this` under initialization to fully-initialized */
+  case class PromoteWarm(pot: Warm, source: Tree, trace: Vector[Tree]) extends Error {
+    def show(implicit ctx: Context): String =
+      "Promoting the value under initialization to be initialized: " + source.show +
+      ". Calling trace:\n" + stacktrace
+
     def report(implicit ctx: Context): Unit = ???
   }
 
   /** Promote a cold value under initialization to fully-initialized */
   case class PromoteCold(source: Tree, trace: Vector[Tree]) extends Error {
-    def message(implicit ctx: Context): String =
+    def show(implicit ctx: Context): String =
       "Promoting the value " + source.show + " to be initialized while it is under initialization" +
       ". Calling trace:\n" + stacktrace
 
     def report(implicit ctx: Context): Unit = ???
   }
 
   case class AccessCold(field: Symbol, source: Tree, trace: Vector[Tree]) extends Error {
-    def message(implicit ctx: Context): String =
+    def show(implicit ctx: Context): String =
       "Access field " + source.show + " on a value under unknown initialization status" +
       ". Calling trace:\n" + stacktrace
 
     def report(implicit ctx: Context): Unit = ???
   }
 
   case class CallCold(meth: Symbol, source: Tree, trace: Vector[Tree]) extends Error {
-    def message(implicit ctx: Context): String =
+    def show(implicit ctx: Context): String =
       "Call method " + source.show + " on a value under unknown initialization" +
       ". Calling trace:\n" + stacktrace
 
     def report(implicit ctx: Context): Unit = ???
   }
 
   case class CallUnknown(meth: Symbol, source: Tree, trace: Vector[Tree]) extends Error {
-    def message(implicit ctx: Context): String =
+    def show(implicit ctx: Context): String =
       "Calling the external method " + meth.show +
       " may cause initialization errors" + ". Calling trace:\n" + stacktrace
 
@@ -89,7 +103,7 @@ object Errors {
 
   /** Promote a value under initialization to fully-initialized */
   case class UnsafePromotion(pot: Potential, source: Tree, trace: Vector[Tree], errors: Set[Error]) extends Error {
-    def message(implicit ctx: Context): String = ???
+    def show(implicit ctx: Context): String = ???
 
     def report(implicit ctx: Context): Unit = ???
   }