Address comments

Author: EnzeXing

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

@@ -1066,9 +1066,6 @@ class Objects(using Context @constructorOnly):
         else if target.equals(defn.Predef_classOf) then
           // Predef.classOf is a stub method in tasty and is replaced in backend
           UnknownValue
-        else if ref.isInstanceOf[ObjectRef] && !ref.asObjectRef.isAfterSuperCall then
-          report.warning("Calling " + target + " of object " + ref.klass + " before the super constructor of the object finishes! " + Trace.show, Trace.position)
-          Bottom
         else if target.hasSource then
           val cls = target.owner.enclosingClass.asClass
           val ddef = target.defTree.asInstanceOf[DefDef]
@@ -1458,7 +1455,11 @@ class Objects(using Context @constructorOnly):
   /** Check an individual object */
   private def accessObject(classSym: ClassSymbol)(using Context, State.Data, Trace, Heap.MutableData, EnvMap.EnvMapMutableData): ObjectRef = log("accessing " + classSym.show, printer, (_: Value).show) {
     if classSym.hasSource then
-      State.checkObjectAccess(classSym)
+      val obj = State.checkObjectAccess(classSym)
+      if !obj.isAfterSuperCall then
+        report.warning("Accessing " + obj.klass + " before the super constructor of the object finishes! " + Trace.show, Trace.position)
+      end if
+      obj
     else
       val obj = ObjectRef(classSym)
       obj.setAfterSuperCall()

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

@@ -18,13 +18,3 @@
   |               │   ^
   |               └── val m: Int = A.n // warn	[ global-cycle7.scala:6 ]
   |                                ^^^
--- Warning: /Users/enzexing/IdeaProjects/dotty-staging/dotty/tests/init-global/warn/global-cycle7.scala:12:66
-12 |  val tokenString, debugString: Array[String] = new Array[String](maxToken + 1)
-   |                                                                  ^^^^^^^^
-   |Calling method maxToken of object module class JavaTokens$ before the super constructor of the object finishes! Calling trace:
-   |├── object JavaTokens extends TokensCommon {	[ global-cycle7.scala:15 ]
-   |│   ^
-   |├── abstract class TokensCommon {	[ global-cycle7.scala:9 ]
-   |│   ^
-   |└── val tokenString, debugString: Array[String] = new Array[String](maxToken + 1)	[ global-cycle7.scala:12 ]
-   |                                                                    ^^^^^^^^

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

@@ -9,7 +9,7 @@ object B {
 abstract class TokensCommon {
   def maxToken: Int
 
-  val tokenString, debugString: Array[String] = new Array[String](maxToken + 1) // warn
+  val tokenString, debugString: Array[String] = new Array[String](maxToken + 1)
 }
 
 object JavaTokens extends TokensCommon {

tests/init-global/warn/i9176.check

@@ -4,5 +4,11 @@
   |            Cyclic initialization: object A -> object B -> object A. Calling trace:
   |            ├── case object A extends Foo(B) // warn	[ i9176.scala:2 ]
   |            │                             ^
-  |            └── case object B extends Foo(A)	[ i9176.scala:3 ]
+  |            └── case object B extends Foo(A) // warn	[ i9176.scala:3 ]
   |                                          ^
+-- Warning: tests/init-global/warn/i9176.scala:3:26 --------------------------------------------------------------------
+3 |case object B extends Foo(A) // warn
+  |                          ^
+  |                     Accessing module class A$ before the super constructor of the object finishes! Calling trace:
+  |                     └── case object B extends Foo(A) // warn	[ i9176.scala:3 ]
+  |                                                   ^

tests/init-global/warn/i9176.scala

@@ -1,6 +1,6 @@
 class Foo(val opposite: Foo)
 case object A extends Foo(B) // warn
-case object B extends Foo(A)
+case object B extends Foo(A) // warn
 object Test {
   def main(args: Array[String]): Unit = {
     println(A.opposite)

tests/init-global/warn/resolve-parent-this.check

@@ -1,3 +1,13 @@
+-- Warning: tests/init-global/warn/resolve-parent-this.scala:3:18 ------------------------------------------------------
+3 |  val f: O.type = O // warn
+  |                  ^
+  |                  Accessing module class O$ before the super constructor of the object finishes! Calling trace:
+  |                  ├── object O extends Delegate {	[ resolve-parent-this.scala:6 ]
+  |                  │   ^
+  |                  ├── class Delegate {	[ resolve-parent-this.scala:1 ]
+  |                  │   ^
+  |                  └── val f: O.type = O // warn	[ resolve-parent-this.scala:3 ]
+  |                                      ^
 -- Warning: tests/init-global/warn/resolve-parent-this.scala:7:21 ------------------------------------------------------
 7 |  val a: Int = foo().a // warn
   |               ^^^^^^^

tests/init-global/warn/resolve-parent-this.scala

@@ -1,6 +1,6 @@
 class Delegate {
   def foo() = f
-  val f: O.type = O
+  val f: O.type = O // warn
 }
 
 object O extends Delegate {

tests/init-global/warn/t9261.check

@@ -4,5 +4,11 @@
   |            Cyclic initialization: object Buy -> object Sell -> object Buy. Calling trace:
   |            ├── case object Buy extends OrderType(Sell) // warn	[ t9261.scala:2 ]
   |            │                                     ^^^^
-  |            └── case object Sell extends OrderType(Buy)	[ t9261.scala:3 ]
+  |            └── case object Sell extends OrderType(Buy) // warn	[ t9261.scala:3 ]
   |                                                   ^^^
+-- Warning: tests/init-global/warn/t9261.scala:3:35 --------------------------------------------------------------------
+3 |case object Sell extends OrderType(Buy) // warn
+  |                                   ^^^
+  |                   Accessing module class Buy$ before the super constructor of the object finishes! Calling trace:
+  |                   └── case object Sell extends OrderType(Buy) // warn	[ t9261.scala:3 ]
+  |                                                          ^^^

tests/init-global/warn/t9261.scala

@@ -1,3 +1,3 @@
 sealed abstract class OrderType(val reverse: OrderType)
 case object Buy extends OrderType(Sell) // warn
-case object Sell extends OrderType(Buy)
+case object Sell extends OrderType(Buy) // warn