Fix tests: more friendly error messages for functions

Author: liufengyun

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

@@ -155,19 +155,19 @@ object Checking {
           pot match {
             case pot @ ThisRef(cls) =>
               assert(cls == state.thisClass, "unexpected potential " + pot.show)
-              PromoteThis(pot, eff.source, state.path).toErrors
+              PromoteThis(pot, eff.source, state2.path).toErrors
 
             case _: Cold =>
-              PromoteCold(eff.source, state.path).toErrors
+              PromoteCold(eff.source, state2.path).toErrors
 
             case pot @ Warm(cls, outer) =>
-              PromoteWarm(pot, eff.source, state.path).toErrors
+              PromoteWarm(pot, eff.source, state2.path).toErrors
 
             case Fun(pots, effs) =>
               val errs1 = effs.flatMap { check(_) }
               val errs2 = pots.flatMap { pot => check(Promote(pot)(eff.source))(state.copy(path = Vector.empty)) }
               if (errs1.nonEmpty || errs2.nonEmpty)
-                UnsafePromotion(pot, eff.source, state.path, errs1 ++ errs2).toErrors
+                UnsafePromotion(pot, eff.source, state2.path, errs1 ++ errs2).toErrors
               else
                 Errors.empty
 
@@ -184,15 +184,15 @@ object Checking {
 
               val target = resolve(cls, field)
               if (target.is(Flags.Lazy)) check(MethodCall(pot, target)(eff.source))
-              else if (!state.fieldsInited.contains(target)) AccessNonInit(target, state.path).toErrors
+              else if (!state.fieldsInited.contains(target)) AccessNonInit(target, state2.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)) AccessNonInit(target, state.path).toErrors
+              else if (!state.fieldsInited.contains(target)) AccessNonInit(target, state2.path).toErrors
               else Errors.empty
 
             case Warm(cls, outer) =>
@@ -202,7 +202,7 @@ object Checking {
               else Errors.empty
 
             case _: Cold =>
-              AccessCold(field, eff.source, state.path).toErrors
+              AccessCold(field, eff.source, state2.path).toErrors
 
             case Fun(pots, effs) =>
               throw new Exception("Unexpected effect " + eff.show)
@@ -224,7 +224,7 @@ object Checking {
                 val effs = thisRef.effectsOf(target)
                 effs.flatMap { check(_) }
               }
-              else CallUnknown(target, eff.source, state.path).toErrors
+              else CallUnknown(target, eff.source, state2.path).toErrors
 
             case SuperRef(thisRef @ ThisRef(cls), supercls) =>
               assert(cls == state.thisClass, "unexpected potential " + pot.show)
@@ -236,7 +236,7 @@ object Checking {
                 val effs = thisRef.effectsOf(target)
                 effs.flatMap { check(_) }
               }
-              else CallUnknown(target, eff.source, state.path).toErrors
+              else CallUnknown(target, eff.source, state2.path).toErrors
 
             case warm @ Warm(cls, outer) =>
               val target = resolve(cls, sym)
@@ -245,11 +245,11 @@ object Checking {
                 val effs = warm.effectsOf(target)
                 effs.flatMap { check(_) }
               }
-              else if (!sym.isConstructor) CallUnknown(target, eff.source, state.path).toErrors
+              else if (!sym.isConstructor) CallUnknown(target, eff.source, state2.path).toErrors
               else Errors.empty
 
             case _: Cold =>
-              CallCold(sym, eff.source, state.path).toErrors
+              CallCold(sym, eff.source, state2.path).toErrors
 
             case Fun(pots, effs) =>
               // TODO: assertion might be false, due to SAM

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

@@ -73,7 +73,7 @@ object Errors {
   /** 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 + "."
+      "Promoting the value under initialization to be initialized."
   }
 
   /** Promote a cold value under initialization to fully-initialized */
@@ -105,7 +105,7 @@ object Errors {
 
     def show(implicit ctx: Context): String = {
       var index = 0
-      "Promoting the value " + source.show + " to initialized is unsafe.\n" + stacktrace +
+      "Promoting the value to initialized is unsafe.\n" + stacktrace +
         "\nThe unsafe promotion may cause the following problem(s):\n" +
         (errors.flatMap(_.flatten).map { error =>
           index += 1

tests/init/crash/final-fields.scala renamed to tests/init/neg/final-fields.scala

@@ -29,8 +29,8 @@ object Test1 extends U {
 }
 
 object Test extends T {
- override final val f1 = /*super.f1*/ 1 + f2
- override final val f2 = 2
+ override final val f1 = /*super.f1*/ 1 + f2  // error
+ override final val f2 = 2                    // error
  override final val f3 = {println(3); 3}      // error
  override val f4 = f3 + 1                     // error
 

tests/init/neg/function10.scala

@@ -1,7 +1,7 @@
 class Base { self =>
-  (0 to 10).foreach { i =>
+  (0 to 10).foreach { i =>             // error
     println(a)
   }
 
-  val a = 10             // error
+  val a = 10
 }

tests/init/neg/function11.scala

@@ -1,11 +1,11 @@
 final class Capture {
   private[this] var m: Boolean = false
 
-  (0 to 10).foreach { i =>
+  (0 to 10).foreach { i =>      // error
     f()
   }
 
-  val a = 10      // error
+  val a = 10
 
   def f() = while ({
     println(a)

tests/init/neg/override15.scala

@@ -1,7 +1,7 @@
 abstract class A {
   val g = (n: Int) => n + y
-  val x: Int = f(g)
-  val y: Int = 10      // error
+  val x: Int = f(g)          // error
+  val y: Int = 10
 
   def f(m: Int => Int): Int
 }

tests/init/neg/override38.scala

@@ -1,14 +1,14 @@
 abstract class A {
   def f: Int
 
-  (1 to 10).foreach { i =>
+  (1 to 10).foreach { i =>  // error
     f
   }
 
   private val a = 10
 }
 
 class B extends A {
-  private val a = 30  // error
+  private val a = 30
   def f: Int = a
 }