Fix #7434: Tighten condition for optimizing synthetic objects in LazyVal

Author: odersky

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

@@ -73,7 +73,11 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     else {
       val isField = sym.owner.isClass
       if (isField)
-        if (sym.isAllOf(SyntheticModule))
+        if sym.isAllOf(SyntheticModule) && sym.allOverriddenSymbols.isEmpty then
+          // I am not sure what the conditions for this optimization should be.
+          // It was applied for all synthetic objects, but this is clearly false, as t704 demonstrates.
+          // It seems we have to at least exclude synthetic objects that derive from mixins.
+          // This is done by demanding that the object does not override anything.
           transformSyntheticModule(tree)
         else if (sym.isThreadUnsafe || ctx.settings.scalajs.value)
           if (sym.is(Module) && !ctx.settings.scalajs.value) {

tests/run/t704.check

@@ -0,0 +1,6 @@
+xxxx should appear twice
+zzzz should appear twice
+yyyy should appear twice
+xxxx should appear twice
+zzzz should appear twice
+yyyy should appear twice

tests/pos/t704.scala renamed to tests/run/t704.scala

@@ -1,21 +1,28 @@
 trait D {
   private val x = "xxxx should appear twice"
-  private object xxxx { Console.println(x) }
+  object xxxx { Console.println(x) }
   def get_xxxx: AnyRef = xxxx
+
+  private val z = "zzzz should appear twice"
+  lazy val zzzz = new ZZZZ
+  class ZZZZ { Console.println(z) }
+  def get_zzzz: AnyRef = zzzz
 }
 
 trait E extends D {
   def f(): Unit = {
     val y = "yyyy should appear twice"
     object yyyy {
       val x1 = get_xxxx
+      val z1 = get_zzzz
       Console.println(y)
     }
     yyyy
   }
 }
 class C extends E {}
-object Go extends D {
+object Test extends D {
+  object E
   def main(args : Array[String]): Unit = {
     new C().f()
     new C().f()