Only conduct check on methods with source

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]
@@ -1082,16 +1079,20 @@ class Objects(using Context @constructorOnly):
               val outerEnvs = Env.resolveEnvByMethod(enclosingMethod, ref, summon[Scope])
               (outerEnvs.joinThisV, outerEnvs)
 
-          val env2 = Env.ofDefDef(ddef, args.map(_.value), thisV, outerEnv)
-          extendTrace(ddef) {
-            given Scope = env2
-            cache.cachedEval(ref, ddef.rhs, cacheResult = true) { expr =>
-              Returns.installHandler(meth)
-              val res = cases(expr, thisV, cls)
-              val returns = Returns.popHandler(meth)
-              res.join(returns)
+          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
+            val env2 = Env.ofDefDef(ddef, args.map(_.value), thisV, outerEnv)
+            extendTrace(ddef) {
+              given Scope = env2
+              cache.cachedEval(ref, ddef.rhs, cacheResult = true) { expr =>
+                Returns.installHandler(meth)
+                val res = cases(expr, thisV, cls)
+                val returns = Returns.popHandler(meth)
+                res.join(returns)
+              }
             }
-          }
         else
           UnknownValue
       else if target.exists then

tests/init-global/warn/call-before-super3.scala

@@ -1,9 +1,9 @@
-abstract class Foo[T](defaultValue: => T, arg1: Int = 1, arg2: Int = 2):
-  def getValue: T = defaultValue
+class C(i: Int = 42, j: Int = 27) {
+  val f = X.foo() // warn
+}
 
-enum Baz:
-  case E1, E2 // warn
+object X extends C(j = 5):
+  def foo() = 5
 
-object Baz extends Foo[Baz](Baz.E1, arg2 = 2) // warn
-
-@main def test = println(Baz.getValue)
+@main def test = println:
+  X

tests/init-global/warn/call-before-super4.scala

@@ -18,3 +18,13 @@
   |               │   ^
   |               └── 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.check

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