Forward reference error includes line numbers (scala#22534)

Fixes scala#14401 where the line number helps the user realize they are
looking at the wrong definition.
[Cherry-picked b4e3d7d]

Author: som-snytt

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

@@ -1212,14 +1212,22 @@ extends DeclarationMsg(OverrideErrorID), NoDisambiguation:
 
 class ForwardReferenceExtendsOverDefinition(value: Symbol, definition: Symbol)(using Context)
 extends ReferenceMsg(ForwardReferenceExtendsOverDefinitionID) {
-  def msg(using Context) = i"${definition.name} is a forward reference extending over the definition of ${value.name}"
+  extension (sym: Symbol) def srcLine = sym.line + 1
+
+  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

@@ -0,0 +1,30 @@
+-- [E039] Reference Error: tests/neg/i14401.scala:6:17 -----------------------------------------------------------------
+6 |    def f: Int = x // error
+  |                 ^
+  |                 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
+   |                 ^
+   |                 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
+   |                 ^
+   |                 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
+   |                    ^
+   |                    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:38:28 ----------------------------------------------------------------
+38 |    class NotUsed {val xs = args} // error
+   |                            ^^^^
+   |                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

@@ -0,0 +1,41 @@
+object Test:
+  def f: Int = x
+  val x: 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] =
+      val fInt = Future.successful(42)
+      val z =
+        for a <- fInt
+        yield a + 27 // error
+      implicit val ec: ExecutionContext = Implicits.global
+      z
+    foo
+
+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