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

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

@@ -9,3 +9,8 @@
   |│           ^^^^^^^
   |└── (() => x) // warn	[ global-irrelevance3.scala:9 ]
   |           ^
+  |The mutable state is created through: 
+  |├── object A:	[ global-irrelevance3.scala:1 ]
+  |│   ^
+  |└── val p: Pair = foo()	[ global-irrelevance3.scala:3 ]
+  |                  ^^^^^

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

@@ -9,3 +9,8 @@
   |       │   ^^^^^^^^^
   |       └── (y => x = y), // warn	[ global-irrelevance4.scala:8 ]
   |            ^^^^^^^^^^
+  |       The mutable state is created through: 
+  |       ├── object A:	[ global-irrelevance4.scala:1 ]
+  |       │   ^
+  |       └── val p: Pair = foo()	[ global-irrelevance4.scala:3 ]
+  |                         ^^^^^

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

@@ -10,7 +10,5 @@
   |The mutable state is created through: 
   |├── object A:	[ mutable-array.scala:1 ]
   |│   ^
-  |├── val box: Box = new Box(0)	[ mutable-array.scala:3 ]
-  |│                  ^^^^^^^^^^
-  |└── class Box(var value: Int)	[ mutable-array.scala:2 ]
-  |    ^^^^^^^^^^^^^^^^^^^^^^^^^
+  |└── val box: Box = new Box(0)	[ mutable-array.scala:3 ]
+  |                   ^^^^^^^^^^

tests/init-global/warn/mutable-array.check

@@ -10,7 +10,5 @@
    |The mutable state is created through: 
    |├── object A:	[ mutable-read1.scala:3 ]
    |│   ^
-   |├── val box: Box = new Box(4)	[ mutable-read1.scala:4 ]
-   |│                  ^^^^^^^^^^
-   |└── class Box(var value: Int)	[ mutable-read1.scala:1 ]
-   |    ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |└── val box: Box = new Box(4)	[ mutable-read1.scala:4 ]
+   |                   ^^^^^^^^^^

tests/init-global/warn/mutable-read1.check

@@ -10,7 +10,5 @@
    |The mutable state is created through: 
    |├── object A:	[ mutable-read2.scala:1 ]
    |│   ^
-   |├── val box: Box = new Box(0)	[ mutable-read2.scala:5 ]
-   |│                  ^^^^^^^^^^
-   |└── class Box(var value: Int) {	[ mutable-read2.scala:2 ]
-   |    ^
+   |└── val box: Box = new Box(0)	[ mutable-read2.scala:5 ]
+   |                   ^^^^^^^^^^

tests/init-global/warn/mutable-read2.check

@@ -10,7 +10,5 @@
   |The mutable state is created through: 
   |├── object A:	[ mutable-read3.scala:1 ]
   |│   ^
-  |├── val box: Box = new Box(0)	[ mutable-read3.scala:3 ]
-  |│                  ^^^^^^^^^^
-  |└── class Box(var value: Int)	[ mutable-read3.scala:2 ]
-  |    ^^^^^^^^^^^^^^^^^^^^^^^^^
+  |└── val box: Box = new Box(0)	[ mutable-read3.scala:3 ]
+  |                   ^^^^^^^^^^

tests/init-global/warn/mutable-read3.check

@@ -10,7 +10,5 @@
    |The mutable state is created through: 
    |├── object A:	[ mutable-read4.scala:3 ]
    |│   ^
-   |├── val box: Box = new Box(4)	[ mutable-read4.scala:4 ]
-   |│                  ^^^^^^^^^^
-   |└── class Box(var value: Int)	[ mutable-read4.scala:1 ]
-   |    ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |└── val box: Box = new Box(4)	[ mutable-read4.scala:4 ]
+   |                   ^^^^^^^^^^

tests/init-global/warn/mutable-read4.check

@@ -12,7 +12,5 @@
   |The mutable state is created through: 
   |├── object Contexts:	[ mutable-read6.scala:3 ]
   |│   ^
-  |├── val NoContext: Context = new Context	[ mutable-read6.scala:4 ]
-  |│                            ^^^^^^^^^^^
-  |└── class Context:	[ mutable-read6.scala:5 ]
-  |    ^
+  |└── val NoContext: Context = new Context	[ mutable-read6.scala:4 ]
+  |                             ^^^^^^^^^^^

tests/init-global/warn/mutable-read6.check

@@ -0,0 +1,20 @@
+-- Warning: tests/init-global/warn/unsoundness.scala:12:6 --------------------------------------------------------------
+12 |    O.x       // warn
+   |    ^^^
+   |    Access uninitialized field value x. Calling trace:
+   |    ├── object O:	[ unsoundness.scala:15 ]
+   |    │   ^
+   |    ├── f(if m > 5 then Box(A(3)) else Box(B(4)))	[ unsoundness.scala:17 ]
+   |    │   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |    ├── def f(a: Box[Base[Int]]): Unit =	[ unsoundness.scala:21 ]
+   |    │   ^
+   |    ├── h(a.value)	[ unsoundness.scala:22 ]
+   |    │   ^^^^^^^^^^
+   |    ├── def h(a: Base[Int]): Unit =	[ unsoundness.scala:24 ]
+   |    │   ^
+   |    ├── a.update(10)	[ unsoundness.scala:25 ]
+   |    │   ^^^^^^^^^^^^
+   |    ├── def update(n: T) =	[ unsoundness.scala:11 ]
+   |    │   ^
+   |    └── O.x       // warn	[ unsoundness.scala:12 ]
+   |        ^^^

tests/init-global/warn/unsoundness.check

@@ -0,0 +1,25 @@
+class Box[T](val value: T)
+
+abstract class Base[T]:
+  def update(n: T): Unit
+
+class A[T](var a: T) extends Base[T]:
+  def update(n: T) =
+    a = n
+
+class B[T](var b: T) extends Base[T]:
+  def update(n: T) =
+    O.x       // warn
+    b = n
+
+object O:
+  val m: Int = 3
+  f(if m > 5 then Box(A(3)) else Box(B(4)))
+
+  val x: Int = 10
+
+  def f(a: Box[Base[Int]]): Unit =
+    h(a.value)
+
+  def h(a: Base[Int]): Unit =
+    a.update(10)