Warning when calling object methods before super constructor finishes

Author: EnzeXing

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

@@ -144,6 +144,8 @@ class Objects(using Context @constructorOnly):
 
     def isObjectRef: Boolean = this.isInstanceOf[ObjectRef]
 
+    def asObjectRef: ObjectRef = this.asInstanceOf[ObjectRef]
+
     def valValue(sym: Symbol)(using Heap.MutableData): Value = Heap.readVal(this, sym)
 
     def varValue(sym: Symbol)(using Heap.MutableData): Value = Heap.readVal(this, sym)
@@ -178,6 +180,12 @@ class Objects(using Context @constructorOnly):
 
   /** A reference to a static object */
   case class ObjectRef private (klass: ClassSymbol)(using Trace) extends Ref:
+    var afterSuperCall = false
+
+    def isAfterSuperCall = afterSuperCall
+
+    def setAfterSuperCall(): Unit = afterSuperCall = true
+
     def owner = klass
 
     def show(using Context) = "ObjectRef(" + klass.show + ")"
@@ -1058,6 +1066,9 @@ 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]
@@ -2112,6 +2123,10 @@ class Objects(using Context @constructorOnly):
       tasks.foreach(task => task())
     end if
 
+    if thisV.isInstanceOf[ObjectRef] && klass == thisV.klass then
+      thisV.asObjectRef.setAfterSuperCall()
+    end if
+
     // class body
     tpl.body.foreach {
       case vdef : ValDef if !vdef.symbol.is(Flags.Lazy) && !vdef.rhs.isEmpty =>

tests/init-global/pos/multiple-by-name.scala

@@ -18,10 +18,3 @@ object O {
   val c = foo2(new Y)
   val d = foo3(new Y)
 }
-
-/**
-  * Pass arg to by-name parameter: create a Fun where body is the argument expression
-  * Read value of by-name parameter: call 'apply' on every possible Fun value of the by-name parameter
-  * Solution: Add special EnvRefs for by-name params;
-  *           differentiate these EnvRefs by the arg tree passed to the by-name param
-  */

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

@@ -0,0 +1,7 @@
+class C(i: Int = 42, j: Int = 27)
+
+object X extends C(j = X.foo()): // warn
+  def foo() = 5
+
+@main def test = println:
+  X

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

@@ -0,0 +1,10 @@
+class C(j: Int)
+
+object A:
+  def foo = X.k // warn
+
+object X extends C(A.foo):
+  def k = 5
+
+@main def test = println:
+  X

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

@@ -0,0 +1,9 @@
+abstract class Foo[T](defaultValue: => T, arg1: Int = 1, arg2: Int = 2):
+  def getValue: T = defaultValue
+
+enum Baz:
+  case E1, E2 // warn
+
+object Baz extends Foo[Baz](Baz.E1, arg2 = 2) // warn
+
+@main def test = println(Baz.getValue)

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

@@ -0,0 +1,9 @@
+class C(i: Int = 42, j: Int = 27) {
+  val f = X.foo() // warn
+}
+
+object X extends C(j = 5):
+  def foo() = 5
+
+@main def test = println:
+  X