Improve the message per excellent review

Author: som-snytt

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

@@ -1215,16 +1215,21 @@ extends DeclarationMsg(OverrideErrorID), NoDisambiguation:
 class ForwardReferenceExtendsOverDefinition(value: Symbol, definition: Symbol)(using Context)
 extends ReferenceMsg(ForwardReferenceExtendsOverDefinitionID) {
   extension (sym: Symbol) def srcLine = sym.line + 1
-  def msg(using Context) = i"${definition.name}${
-    if value != definition then s" (defined on L${definition.srcLine})" else ""
-  } is a forward reference extending over the definition of ${value.name} (on L${value.srcLine})"
+
+  def msg(using Context) =
+    val ref =
+      if value != definition then i"${definition.name} (defined on line ${definition.srcLine})"
+      else i"${definition.name}"
+    i"forward reference to ${ref} extends over the definition of ${value.name} (on line ${value.srcLine})"
 
   def explain(using Context) =
     i"""|${definition.name} is used before you define it, and the definition of ${value.name}
         |appears between that use and the definition of ${definition.name}.
         |
-        |Forward references are allowed only, if there are no value definitions between
-        |the reference and the referred method definition.
+        |Forward references are allowed only if there are no value definitions between
+        |the reference and the definition that is referred to.
+        |Specifically, any statement between the reference and the definition
+        |cannot be a variable definition, and if it's a value definition, it must be lazy.
         |
         |Define ${definition.name} before it is used,
         |or move the definition of ${value.name} so it does not appear between

tests/neg/i14401.check

@@ -1,30 +1,30 @@
 -- [E039] Reference Error: tests/neg/i14401.scala:6:17 -----------------------------------------------------------------
-6 |    def f: Int = x; // error
+6 |    def f: Int = x // error
   |                 ^
-  |                 x is a forward reference extending over the definition of x (on L7)
+  |                 forward reference to x extends over the definition of x (on line 7)
   |
   | longer explanation available when compiling with `-explain`
 -- [E039] Reference Error: tests/neg/i14401.scala:10:17 ----------------------------------------------------------------
-10 |    def f: Int = g; // error
+10 |    def f: Int = g // error
    |                 ^
-   |                 g (defined on L12) is a forward reference extending over the definition of x (on L11)
+   |                 forward reference to g (defined on line 12) extends over the definition of x (on line 11)
    |
    | longer explanation available when compiling with `-explain`
 -- [E039] Reference Error: tests/neg/i14401.scala:15:17 ----------------------------------------------------------------
-15 |    def f: Int = g; // error
+15 |    def f: Int = g // error
    |                 ^
-   |                 g (defined on L17) is a forward reference extending over the definition of x (on L16)
+   |                 forward reference to g (defined on line 17) extends over the definition of x (on line 16)
    |
    | longer explanation available when compiling with `-explain`
 -- [E039] Reference Error: tests/neg/i14401.scala:31:20 ----------------------------------------------------------------
-31 |      } yield a + 27 // error
+31 |        yield a + 27 // error
    |                    ^
-   |                    ec (defined on L33) is a forward reference extending over the definition of z (on L29)
+   |                    forward reference to ec (defined on line 32) extends over the definition of z (on line 29)
    |
    | longer explanation available when compiling with `-explain`
--- [E039] Reference Error: tests/neg/i14401.scala:41:28 ----------------------------------------------------------------
-41 |    class NotUsed {val xs = args} // error
+-- [E039] Reference Error: tests/neg/i14401.scala:38:28 ----------------------------------------------------------------
+38 |    class NotUsed {val xs = args} // error
    |                            ^^^^
-   |                    args (defined on L44) is a forward reference extending over the definition of dummy (on L42)
+   |                forward reference to args (defined on line 41) extends over the definition of dummy (on line 39)
    |
    | longer explanation available when compiling with `-explain`

tests/neg/i14401.scala

@@ -1,46 +1,41 @@
-object Test {
-  def f: Int = x;
-  val x: Int = f;
+object Test:
+  def f: Int = x
+  val x: Int = f
 
-  {
-    def f: Int = x; // error
-    val x: Int = f;
-  }
-  {
-    def f: Int = g; // error
-    val x: Int = f;
-    def g: Int = x;
-  }
-  {
-    def f: Int = g; // error
-    var x: Int = f;
-    def g: Int = x;
-  }
-  {
-    def f: Int = g;
-    Console.println("foo");
-    def g: Int = f;
-  }
-  {
+  locally:
+    def f: Int = x // error
+    val x: Int = f
+
+  locally:
+    def f: Int = g // error
+    val x: Int = f
+    def g: Int = x
+
+  locally:
+    def f: Int = g // error
+    var x: Int = f
+    def g: Int = x
+
+  locally:
+    def f: Int = g
+    Console.println("foo")
+    def g: Int = f
+
+  locally:
     import scala.concurrent.{ExecutionContext, Future}, ExecutionContext.Implicits
 
-    def foo: Future[Int] = {
+    def foo: Future[Int] =
       val fInt = Future.successful(42)
-      val z = for {
-        a <- fInt
-      } yield a + 27 // error
-
+      val z =
+        for a <- fInt
+        yield a + 27 // error
       implicit val ec: ExecutionContext = Implicits.global
       z
-    }
     foo
-  }
-}
-object MyApp {
-  def main(args: Array[String]) = {
+
+object MyApp:
+  def main(args: Array[String]) =
     class NotUsed {val xs = args} // error
     val dummy = false
     // oops, shadows the parameter
     def args = Seq("a","b","c")
-  }
-}

tests/neg/i14401b.check

@@ -0,0 +1,20 @@
+-- [E039] Reference Error: tests/neg/i14401b.scala:5:17 ----------------------------------------------------------------
+5 |    def f: Int = x; // error
+  |                 ^
+  |                 forward reference to x extends over the definition of x (on line 6)
+  |---------------------------------------------------------------------------------------------------------------------
+  | Explanation (enabled by `-explain`)
+  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  | x is used before you define it, and the definition of x
+  | appears between that use and the definition of x.
+  |
+  | Forward references are allowed only if there are no value definitions between
+  | the reference and the definition that is referred to.
+  | Specifically, any statement between the reference and the definition
+  | cannot be a variable definition, and if it's a value definition, it must be lazy.
+  |
+  | Define x before it is used,
+  | or move the definition of x so it does not appear between
+  | the declaration of x and its use,
+  | or define x as lazy.
+   ---------------------------------------------------------------------------------------------------------------------

tests/neg/i14401b.scala

@@ -0,0 +1,6 @@
+//> using options --explain
+
+object Test:
+  locally:
+    def f: Int = x; // error
+    val x: Int = f;

tests/neg/i14401c.check

@@ -0,0 +1,20 @@
+-- [E039] Reference Error: tests/neg/i14401c.scala:5:17 ----------------------------------------------------------------
+5 |    def f: Int = g // error
+  |                 ^
+  |                 forward reference to g (defined on line 7) extends over the definition of x (on line 6)
+  |---------------------------------------------------------------------------------------------------------------------
+  | Explanation (enabled by `-explain`)
+  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  | g is used before you define it, and the definition of x
+  | appears between that use and the definition of g.
+  |
+  | Forward references are allowed only if there are no value definitions between
+  | the reference and the definition that is referred to.
+  | Specifically, any statement between the reference and the definition
+  | cannot be a variable definition, and if it's a value definition, it must be lazy.
+  |
+  | Define g before it is used,
+  | or move the definition of x so it does not appear between
+  | the declaration of g and its use,
+  | or define x as lazy.
+   ---------------------------------------------------------------------------------------------------------------------

tests/neg/i14401c.scala

@@ -0,0 +1,7 @@
+//> using options --explain
+
+object Test:
+  locally:
+    def f: Int = g // error
+    var x: Int = f
+    def g: Int = x