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

@@ -11,10 +11,37 @@ import dotty.tools.dotc.core._
 import dotty.tools.dotc.transform.MegaPhase._
 import dotty.tools.dotc.transform.SymUtils._
 
-/** Removes selects that would be compiled into GetStatic
- * otherwise backend needs to be aware that some qualifiers need to be dropped.
- * Similar transformation seems to be performed by flatten in nsc
- * @author Dmytro Petrashko
+/** Removes `Select`s that would be compiled into `GetStatic`.
+ *
+ *  Otherwise, the backend needs to be aware that some qualifiers need to be
+ *  dropped.
+ *
+ *  A tranformation similar to what this phase does seems to be performed by
+ *  flatten in nsc.
+ *
+ *  The side effects of the qualifier of a dropped `Select` is normally
+ *  retained. As an exception, the qualifier is completely dropped if it is
+ *  a reference to a static owner (see `isStaticOwnerRef`). Concretely, this
+ *  means that in
+ *
+ *  {{{
+ *  object Foo {
+ *    println("side effects")
+ *
+ *    object Bar
+ *    class Baz
+ *  }
+ *
+ *  Foo.Bar
+ *  new Foo.Baz()
+ *  }}}
+ *
+ *  the `Foo` qualifiers will be dropped, since it is a static object. The
+ *  `println("side effects")` will therefore not be executed.
+ *
+ *  This intended behavior is equivalent to what scalac does.
+ *
+ *  @author Dmytro Petrashko
  */
 class SelectStatic extends MiniPhase with IdentityDenotTransformer {
   import ast.tpd._
@@ -29,13 +56,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