Modified abstract domain in global initialization checker (#23138)

This PR modifies the abstract domain of the global object initialization
checker. It closely follows the abstract definitional interpreter
framework, but changes the heap to map from scopes (including abstract
objects or local environments) to a pair of `valsMap` and `outersMap`,
both of which over-approximates the information of scope bodies of the
concrete scopes they represent.

[test_scala2_library_tasty]

Author: olhotak

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

@@ -15,4 +15,6 @@ global-list.scala
 t5366.scala
 mutable-read7.scala
 t9115.scala
-Color.scala
+Color.scala
+unapplySeq-implicit-arg2.scala
+unapplySeq-implicit-arg3.scala

compiler/test/dotc/neg-init-global-scala2-library-tasty.excludelist

@@ -0,0 +1,7 @@
+class B {}
+
+class C(c: B) extends B
+
+object O:
+    def f(param: B): Int = f(new C(param))
+    val a = f(new B)

tests/init-global/pos/cyclic-param.scala

@@ -0,0 +1,9 @@
+object O:
+    val a = m(2)
+    def m(f: Int) =
+        val a = f
+        () => a
+
+object O2:
+    val func = O.a
+    val a = func()

tests/init-global/pos/get-local-val-from-other-owner.scala

@@ -0,0 +1,4 @@
+class A(val a: A)
+object B:
+    val a: A = loop().a
+    def loop(): A = new A(loop())

tests/init-global/pos/global-recursion3.scala

@@ -0,0 +1,14 @@
+class Outer {
+  val f = 5
+  class Inner extends Outer {
+    val g = Outer.this.f
+  }
+}
+
+object O {
+  def foo(i: Outer): Unit =
+    val i2 = new i.Inner // i2.outer should always be OfClass(Outer)
+    foo(i2)
+
+  foo(new Outer)
+}

tests/init-global/pos/inner-extends-outer.scala

@@ -0,0 +1,22 @@
+class Outer {
+  def foo = {
+    val y = 5
+    class C {
+      val x = y
+    }
+    class D {
+      new C
+    }
+
+    new D
+  }
+
+  foo
+
+  val n = 10 // warn
+}
+
+object O {
+  val c = new Outer
+  val d: Object = c.foo
+}

tests/init-global/pos/local-class.scala

@@ -10,7 +10,7 @@ object O:
   def bar(t: T) = {
     class A {
       class B {
-        t.foo() // warn
+        t.foo()
       }
 
       val b = new B

tests/init-global/warn/widen.scala renamed to tests/init-global/pos/lookup-outer.scala

@@ -8,12 +8,8 @@
   |       │                ^
   |       ├── object B {	[ global-cycle6.scala:8 ]
   |       │   ^
-  |       ├── val a = new A.Inner	[ global-cycle6.scala:9 ]
-  |       │           ^^^^^^^^^^^
-  |       ├── class Inner {	[ global-cycle6.scala:3 ]
-  |       │   ^
-  |       └── println(n) // warn	[ global-cycle6.scala:4 ]
-  |                   ^
+  |       └── val a = new A.Inner	[ global-cycle6.scala:9 ]
+  |                   ^^^^^^^^^^^
 -- Warning: tests/init-global/warn/global-cycle6.scala:4:12 ------------------------------------------------------------
 4 |    println(n) // warn
   |            ^
@@ -26,3 +22,15 @@
   |            │   ^
   |            └── println(n) // warn	[ global-cycle6.scala:4 ]
   |                        ^
+-- Warning: tests/init-global/warn/global-cycle6.scala:14:9 ------------------------------------------------------------
+14 |  object A { // warn
+   |         ^
+   |         Cyclic initialization: object A -> object B -> object A. Calling trace:
+   |         ├── object A { // warn	[ global-cycle6.scala:14 ]
+   |         │   ^
+   |         ├── val n: Int = B.m	[ global-cycle6.scala:15 ]
+   |         │                ^
+   |         ├── object B {	[ global-cycle6.scala:21 ]
+   |         │   ^
+   |         └── val a = new A.Inner	[ global-cycle6.scala:22 ]
+   |                     ^^^^^^^^^^^

tests/init-global/warn/global-cycle6.check

@@ -11,7 +11,7 @@ object B {
 }
 
 object O {
-  object A {
+  object A { // warn
     val n: Int = B.m
     class Inner {
       val x: Int = 4