Update abstract domain and tests

Author: EnzeXing

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

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

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

@@ -11,15 +11,20 @@ class A(val x: Int) {
     }
   }
 }
-class AA(x: Int) extends A(x) {
+class AA(y: Int) extends A(y+1) {
+  class E {}
   def foo = {
     val a = if true then new A(42) else new AA(46)
     println("a = " + a.hashCode())
     class C /*outer: AA(44) (`Main.aa`)*/ extends a.B /*outer: A(42) or AA(46) (`a`)*/ {
       println("AA.this = " + AA.this.hashCode()) // Main.aa
       println("AA.this.x = " + x) // C --> outer AA --> parent A (44)
       override def fooz2 = x // 44
+      val z = fooz // (A.this.x)
+      println("z = " + z)
+
     }
+    class B extends AA.this.E {}
     val c: C = new C
     println("c = " + c.hashCode())
     val d = new c.D // outer: C (`c`)

tests/init-global/pos/multiple-outers.scala

@@ -0,0 +1,20 @@
+class A {
+  val field_a = 5
+  def bar(): Int = A.this.field_a
+}
+
+class B extends A {
+  val field_b = field_a
+  class C {
+    def bar2() = B.this.field_b
+    val field_c = bar() // expands to B.this.bar()
+    val field_c2 = field_a // C --> outer B --> parent A
+  }
+}
+
+object O:
+  val b = new B
+  class D extends b.C { // D --> parent C --> outer B
+    val field_d = bar2()
+  }
+  val d = new D

tests/init-global/pos/resolve-outer-of-parent.scala

@@ -8,8 +8,12 @@
   |       │                ^
   |       ├── object B {	[ global-cycle6.scala:8 ]
   |       │   ^
-  |       └── val a = new A.Inner	[ global-cycle6.scala:9 ]
-  |                   ^^^^^^^^^^^
+  |       ├── val a = new A.Inner	[ global-cycle6.scala:9 ]
+  |       │           ^^^^^^^^^^^
+  |       ├── class Inner {	[ global-cycle6.scala:3 ]
+  |       │   ^
+  |       └── println(n) // warn	[ global-cycle6.scala:4 ]
+  |                   ^
 -- Warning: tests/init-global/warn/global-cycle6.scala:4:12 ------------------------------------------------------------
 4 |    println(n) // warn
   |            ^
@@ -22,15 +26,3 @@
   |            │   ^
   |            └── 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 { // warn
+  object A {
     val n: Int = B.m
     class Inner {
       val x: Int = 4

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

@@ -0,0 +1,16 @@
+-- Warning: tests/init-global/warn/inner-extends-outer.scala:22:19 -----------------------------------------------------
+22 |  def bar(): Int = f2 // warn
+   |                   ^^
+   |                   Access uninitialized field value f2. Calling trace:
+   |                   ├── object O extends T {	[ inner-extends-outer.scala:15 ]
+   |                   │   ^
+   |                   ├── val f1 = foo(new Outer(this))	[ inner-extends-outer.scala:20 ]
+   |                   │            ^^^^^^^^^^^^^^^^^^^^
+   |                   ├── def foo(i: Outer): Int =	[ inner-extends-outer.scala:16 ]
+   |                   │   ^
+   |                   ├── i2.g()	[ inner-extends-outer.scala:18 ]
+   |                   │   ^^^^^^
+   |                   ├── def g(): Int = Outer.this.t.bar()	[ inner-extends-outer.scala:11 ]
+   |                   │                  ^^^^^^^^^^^^^^^^^^
+   |                   └── def bar(): Int = f2 // warn	[ inner-extends-outer.scala:22 ]
+   |                                        ^^

tests/init-global/warn/inner-extends-outer.check

@@ -0,0 +1,23 @@
+trait T {
+  def bar(): Int
+}
+
+class C extends T {
+  def bar(): Int = 5
+}
+
+class Outer(val t: T) {
+  class Inner extends Outer(new C) {
+    def g(): Int = Outer.this.t.bar()
+  }
+}
+
+object O extends T {
+  def foo(i: Outer): Int =
+    val i2 = new i.Inner // i2.outer should always be OfClass(Outer)
+    i2.g()
+
+  val f1 = foo(new Outer(this))
+  val f2 = 5
+  def bar(): Int = f2 // warn
+}

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

@@ -0,0 +1,16 @@
+-- Warning: tests/init-global/warn/resolve-outer-of-parent.scala:7:16 --------------------------------------------------
+7 |  def foo() = O.d // warn
+  |              ^^^
+  |              Access uninitialized field value d. Calling trace:
+  |              ├── object O:	[ resolve-outer-of-parent.scala:14 ]
+  |              │   ^
+  |              ├── val d = new D	[ resolve-outer-of-parent.scala:19 ]
+  |              │           ^^^^^
+  |              ├── class D extends b.C { // D --> parent C --> outer B	[ resolve-outer-of-parent.scala:16 ]
+  |              │   ^
+  |              ├── val field_d = bar2()	[ resolve-outer-of-parent.scala:17 ]
+  |              │                 ^^^^^^
+  |              ├── def bar2() = B.this.foo()	[ resolve-outer-of-parent.scala:9 ]
+  |              │                ^^^^^^^^^^^^
+  |              └── def foo() = O.d // warn	[ resolve-outer-of-parent.scala:7 ]
+  |                              ^^^

tests/init-global/warn/resolve-outer-of-parent.check

@@ -0,0 +1,19 @@
+class A {
+  val field_a = 5
+  def bar(): Int = A.this.field_a
+}
+
+class B extends A {
+  def foo() = O.d // warn
+  class C {
+    def bar2() = B.this.foo()
+    val field_c = bar() // expands to B.this.bar()
+  }
+}
+
+object O:
+  val b = new B
+  class D extends b.C { // D --> parent C --> outer B
+    val field_d = bar2()
+  }
+  val d = new D