Do not load enclosing objects when accessing inner static classes and objects.

This restores parity with the run-time semantics of Scala 2. When
accessing an inner static class or object, we avoid loading the
enclosing objects as values.

The discrepancy in run-time semantics was introduced as a
by-product of #1445
The change in `t4859.check` restores it to its previous state,
before that PR.

Author: sjrd

compiler/src/dotty/tools/dotc/transform/SelectStatic.scala

@@ -29,13 +29,23 @@ class SelectStatic extends MiniPhase with IdentityDenotTransformer {
       sym.isScalaStatic
     val isStaticRef = !sym.is(Package) && !sym.maybeOwner.is(Package) && isStaticMember
     val tree1 =
-      if (isStaticRef && !tree.qualifier.symbol.isAllOf(JavaModule) && !tree.qualifier.isType)
-        Block(List(tree.qualifier), ref(sym))
+      if isStaticRef && !tree.qualifier.symbol.isAllOf(JavaModule) && !tree.qualifier.isType then
+        if isStaticOwnerRef(tree.qualifier) then ref(sym)
+        else Block(List(tree.qualifier), ref(sym))
       else tree
 
     normalize(tree1)
   }
 
+  private def isStaticOwnerRef(tree: Tree)(using Context): Boolean = tree match {
+    case Ident(_) =>
+      tree.symbol.is(Module) && tree.symbol.moduleClass.isStaticOwner
+    case Select(qual, _) =>
+      isStaticOwnerRef(qual) && tree.symbol.is(Module) && tree.symbol.moduleClass.isStaticOwner
+    case _ =>
+      false
+  }
+
   private def normalize(t: Tree)(using Context) = t match {
     case Select(Block(stats, qual), nm) =>
       Block(stats, cpy.Select(t)(qual, nm))

tests/run/no-init-enclosing-static-objects.check

@@ -0,0 +1,11 @@
+InnerObject constructor
+42
+InnerClass constructor
+5
+42
+InnerClass constructor
+5
+getEnclosing2()
+Enclosing2 constructor
+Enclosing2.InnerObject constructor
+65

tests/run/no-init-enclosing-static-objects.scala

@@ -0,0 +1,49 @@
+object Enclosing1 {
+  println("must not be executed")
+
+  object InnerObject {
+    val foo: Int = 42
+    println("InnerObject constructor")
+  }
+
+  class InnerClass(val foo: Int) {
+    println("InnerClass constructor")
+  }
+}
+
+object Enclosing2 {
+  println("Enclosing2 constructor")
+
+  object InnerObject {
+    val foo: Int = 65
+    println("Enclosing2.InnerObject constructor")
+  }
+}
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    testExplicit()
+    testThroughImport()
+    testThroughFunction()
+  }
+
+  def testExplicit(): Unit = {
+    println(Enclosing1.InnerObject.foo)
+    println(new Enclosing1.InnerClass(5).foo)
+  }
+
+  def testThroughImport(): Unit = {
+    import Enclosing1._
+    println(InnerObject.foo)
+    println(new InnerClass(5).foo)
+  }
+
+  def testThroughFunction(): Unit = {
+    println(getEnclosing2().InnerObject.foo)
+  }
+
+  def getEnclosing2(): Enclosing2.type = {
+    println("getEnclosing2()")
+    Enclosing2
+  }
+}

tests/run/t4859.check

@@ -1,7 +1,7 @@
-Outer
 Inner
 Inner.i
 About to reference Inner.i
+Outer
 Inner.i
 About to reference O.N
 About to reference O.N