More fine-grained analysis for inner classes of static objects

Author: liufengyun

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

@@ -89,6 +89,14 @@ object Checking {
     } error.issue
   }
 
+  /** Whether it's known to be safe to access an object */
+  private def isObjectAccessSafe(obj: Global)(using state: State): Boolean =
+    obj.moduleClass == state.thisClass
+    && (obj.enclosingClass == state.thisClass
+        || obj.appearsInside(state.thisClass) && state.superConstrCalled)
+
+// ------- checking construtor ---------------------------
+
   /** Check that the given concrete class may be initialized safely
    *
    *  It assumes that all definitions are properly summarized before-hand.
@@ -197,6 +205,8 @@ object Checking {
     tpl.body.foreach { checkClassBodyStat(_) }
   }
 
+// ------- checking effects ---------------------------
+
   private def checkMethodCall(eff: MethodCall)(using state: State): Errors =
     val MethodCall(pot, sym) = eff
     pot match {
@@ -234,12 +244,18 @@ object Checking {
 
       case hot: Hot =>
         val target = resolve(hot.classSymbol, sym)
-        state.dependencies += StaticCall(hot.classSymbol, target)(state.path)
-        Errors.empty
+        if (target.hasSource && hot.classSymbol.owner == state.thisClass) { // for inner classes of objects
+          val effs = hot.effectsOf(target).toList
+          effs.flatMap { check(_) }
+        }
+        else {
+          state.dependencies += StaticCall(hot.classSymbol, target)(state.path)
+          Errors.empty
+        }
 
       case obj: Global  =>
         val target = resolve(obj.moduleClass, sym)
-        if obj.enclosingClass == state.thisClass && obj.moduleClass == state.thisClass then
+        if isObjectAccessSafe(obj) then
           check(MethodCall(ThisRef()(obj.source), target)(eff.source))
         else
           state.dependencies += StaticCall(obj.moduleClass, target)(state.path)
@@ -291,7 +307,7 @@ object Checking {
         // or all fields are already initialized
         val target = resolve(obj.moduleClass, field)
         if (target.is(Flags.Lazy)) check(MethodCall(obj, target)(eff.source))
-        else if obj.enclosingClass == state.thisClass && obj.moduleClass == state.thisClass then
+        else if isObjectAccessSafe(obj) then
           check(FieldAccess(ThisRef()(obj.source), target)(eff.source))
         else Errors.empty
 
@@ -390,12 +406,12 @@ object Checking {
 
   private def checkAccessGlobal(eff: AccessGlobal)(using state: State): Errors =
     val obj = eff.potential
-    if obj.moduleClass != state.thisClass
-       || obj.enclosingClass != state.thisClass && !state.superConstrCalled
-    then
+    if !isObjectAccessSafe(obj) then
       state.dependencies += ObjectAccess(obj.symbol)(state.path)
     Errors.empty
 
+// ------- expansion of potentials ---------------------------
+
   private def expand(pot: Potential)(using state: State): Summary = trace("expand " + pot.show, init, _.asInstanceOf[Summary].show) {
     pot match {
       case MethodReturn(pot1, sym) =>

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

@@ -13,7 +13,7 @@ import reporting._
 import config.Printers.init
 import ast.tpd._
 
-import Errors._, Potentials._, Effects._
+import Errors._, Potentials._, Effects._, Util._
 
 import scala.collection.mutable
 
@@ -99,6 +99,8 @@ class CycleChecker(cache: Cache) {
       val res = op(using state2)
       res
 
+    def stackTrace: Vector[Tree] = trace.flatMap(_.source)
+
   }
 
   def state(using ev: State) = ev
@@ -160,6 +162,8 @@ class CycleChecker(cache: Cache) {
     if !classesInCurrentRun.contains(dep.cls) || !classesInCurrentRun.contains(dep.symbol.owner)  then
       Util.traceIndented("skip " + dep.show + " which is not in current run ", init)
       Nil
+    else if !dep.symbol.hasSource then
+      CallUnknown(dep.symbol, dep.source.last, state.stackTrace) :: Nil
     else {
       val deps = methodDependencies(dep)
       deps.flatMap(check(_))
@@ -169,6 +173,8 @@ class CycleChecker(cache: Cache) {
     if !classesInCurrentRun.contains(dep.cls) || !classesInCurrentRun.contains(dep.symbol.owner) then
       Util.traceIndented("skip " + dep.show + " which is not in current run ", init)
       Nil
+    else if !dep.symbol.hasSource then
+      CallUnknown(dep.symbol, dep.source.last, state.stackTrace) :: Nil
     else {
       val deps = proxyDependencies(dep)
       deps.flatMap(check(_))

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

@@ -167,6 +167,9 @@ object Potentials {
     def show(using Context): String = symbol.show
 
     def moduleClass(using Context): ClassSymbol = symbol.moduleClass.asClass
+
+    def appearsInside(sym: Symbol)(using Context): Boolean =
+      enclosingClass.ownersIterator.exists(_ == sym)
   }
 
   /** The potential of a hot object

tests/init/neg/features-trees2.scala

@@ -1,6 +1,6 @@
-object Trees {                    // error
+object Trees {
   class ValDef { counter += 1 }
   class EmptyValDef extends ValDef
   val theEmptyValDef = new EmptyValDef
-  private var counter = 0
+  private var counter = 0                // error
 }

tests/init/neg/global-cycle11.scala

@@ -0,0 +1,22 @@
+import scala.collection.mutable
+
+object NameKinds {
+  private val qualifiedNameKinds = mutable.HashMap[Int, QualifiedNameKind]()
+
+  val QualifiedName: QualifiedNameKind = new QualifiedNameKind(2, ".")
+
+  abstract class NameKind(val tag: Int)
+
+  class QualifiedNameKind(tag: Int, val separator: String)
+  extends NameKind(tag) {
+    qualifiedNameKinds(tag) = this
+  }
+}
+
+object A {              // error
+  val n: Int = B.m
+}
+
+object B {
+  val m: Int = A.n
+}

tests/init/neg/global-cycle9.scala

@@ -1,4 +1,4 @@
-object Names {              // error
+object Names {
   abstract class Name
 
   abstract class TermName extends Name:
@@ -18,3 +18,11 @@ object Names {              // error
 
   val nameTable = NameTable()
 }
+
+object A {              // error
+  val n: Int = B.m
+}
+
+object B {
+  val m: Int = A.n
+}

tests/init/neg/inner9.scala

@@ -1,11 +1,11 @@
-object Flags {     // error
+object Flags {
   class Inner {
     println(b)
   }
 
   new Flags.Inner
 
-  val b = 5
+  val b = 5        // error
 }
 
 object Flags2 {