Handle object access semantics depending on locations

Author: liufengyun

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

@@ -227,14 +227,19 @@ object Checking {
         else
           Errors.empty
 
-      case pot @ (_: Hot | _: Global)  =>
-        val cls = pot match
-          case hot: Hot => hot.classSymbol
-          case obj: Global => obj.moduleClass
-        val target = resolve(cls, sym)
-        state.dependencies += StaticCall(cls, target)(pot.source)
+      case hot: Hot =>
+        val target = resolve(hot.classSymbol, sym)
+        state.dependencies += StaticCall(hot.classSymbol, target)(pot.source)
         Errors.empty
 
+      case obj: Global  =>
+        val target = resolve(obj.moduleClass, sym)
+        if obj.enclosingClass == state.thisClass && obj.moduleClass == state.thisClass then
+          check(MethodCall(ThisRef()(obj.source), target)(eff.source))
+        else
+          state.dependencies += StaticCall(obj.moduleClass, target)(pot.source)
+          Errors.empty
+
       case _: Cold =>
         CallCold(sym, eff.source, state.path).toErrors
 
@@ -281,6 +286,8 @@ 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
+          check(FieldAccess(ThisRef()(obj.source), target)(eff.source))
         else Errors.empty
 
       case _: Cold =>
@@ -378,7 +385,8 @@ object Checking {
 
   private def checkAccessGlobal(eff: AccessGlobal)(using state: State): Errors =
     val obj = eff.potential
-    state.dependencies += ObjectAccess(obj.symbol)(eff.source)
+    if obj.enclosingClass != obj.moduleClass then
+      state.dependencies += ObjectAccess(obj.symbol)(eff.source)
     Errors.empty
 
   private def expand(pot: Potential)(using state: State): Summary = trace("expand " + pot.show, init, _.asInstanceOf[Summary].show) {

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

@@ -17,8 +17,6 @@ import Errors._, Potentials._, Effects._
 
 import scala.collection.mutable
 
-
-
 /** The dependencies of a static object or a class
  *
  *  This class is used in checking cyclic initialization of static objects.

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

@@ -159,8 +159,11 @@ object Potentials {
       "Fun[pots = " + potentials.map(_.show).mkString(";") + ", effs = " + effects.map(_.show).mkString(";") + "]"
   }
 
-  /** Reference to a global object */
-  case class Global(symbol: Symbol)(val source: Tree) extends Refinable {
+  /** Reference to a global object
+   *
+   *  @param enclosingClass The class where the reference appears in
+   */
+  case class Global(symbol: Symbol, enclosingClass: ClassSymbol)(val source: Tree) extends Refinable {
     def show(using Context): String = symbol.show
 
     def moduleClass(using Context): ClassSymbol = symbol.moduleClass.asClass

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

@@ -46,7 +46,8 @@ object Summarization {
         else if (!sym.exists) // polymorphic function apply and structural types
           Summary(pots.promote(expr) ++ effs)
         else if (sym.is(Flags.Module) && sym.isStatic)
-          Summary(effs) + Global(sym)(expr)
+          val enclosing = env.ctx.owner.lexicallyEnclosingClass.asClass
+          Summary(effs) + Global(sym, enclosing)(expr)
         else {
           val Summary(pots2, effs2) = pots.select(expr.symbol, expr)
           Summary(pots2, effs ++ effs2)
@@ -249,7 +250,8 @@ object Summarization {
           // self reference to an object inside the object
           Summary(ThisRef()(source))
         else
-          val pot = Global(tmref.symbol)(source)
+          val enclosing = env.ctx.owner.lexicallyEnclosingClass.asClass
+          val pot = Global(tmref.symbol, enclosing)(source)
           Summary(pot) + AccessGlobal(pot)
 
       case tmref: TermRef =>
@@ -261,16 +263,14 @@ object Summarization {
         }
 
       case ThisType(tref) =>
+        val enclosing = env.ctx.owner.lexicallyEnclosingClass.asClass
         if tref.symbol.is(Flags.Module, butNot = Flags.Package)
           && tref.symbol.isStatic
-          && env.ctx.owner.isStatic
-          && tref.symbol != env.ctx.owner
         then
           val sym = tref.symbol.sourceModule
-          val pot = Global(sym)(source)
+          val pot = Global(sym, enclosing)(source)
           Summary(pot) + AccessGlobal(pot)
         else
-          val enclosing = env.ctx.owner.lexicallyEnclosingClass.asClass
           val cls = tref.symbol.asClass
           resolveThis(cls, ThisRef()(source), enclosing, source)
 
@@ -312,7 +312,8 @@ object Summarization {
     else if (pot.size > 2) Summary(Promote(pot)(source))
     else if (cls.is(Flags.Module) && !cur.ownersIterator.exists(_ == cls)) {
       // Dotty uses O$.this outside of the object O
-      val pot = Global(cls.sourceModule)(source)
+      val enclosing = env.ctx.owner.lexicallyEnclosingClass.asClass
+      val pot = Global(cls.sourceModule, enclosing)(source)
       Summary(pot) + AccessGlobal(pot)
     }
     else {

tests/init/neg/features-trees2.scala

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

tests/init/neg/global-cycle7.scala

@@ -0,0 +1,18 @@
+object A {              // error
+  val n: Int = B.m
+}
+
+object B {
+  val m: Int = A.n
+}
+
+abstract class TokensCommon {
+  def maxToken: Int
+
+  val tokenString, debugString: Array[String] = new Array[String](maxToken + 1)
+}
+
+object JavaTokens extends TokensCommon {
+  final def maxToken: Int = DOUBLE
+  final val DOUBLE = 188
+}

tests/init/neg/inner9.scala

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