Fix t4859

Author: OlivierBlanvillain

compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala

@@ -245,7 +245,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           case _ => fun
         }
         val constructor = a.symbol.owner.companionClass.primaryConstructor.asTerm
-        rollInArgs(argss.tail, New(a.tpe.widenDealias, constructor, argss.head))
+        evalReciever(a, rollInArgs(argss.tail, New(a.tpe.widenDealias, constructor, argss.head)))
 
       // For synthetic dotty unapplies on case classes:
       // - CC.unapply(arg): CC → arg
@@ -1207,12 +1207,12 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     // Either a duplicate or a read through series of immutable fields
     val copies = mutable.HashMap[Symbol, Tree]()
     def visitType(tp: Type): Unit = {
-          tp.foreachPart(x => x match {
-            case TermRef(NoPrefix, _) =>
-              val b4 = timesUsedAsType.getOrElseUpdate(x.termSymbol, 0)
-              timesUsedAsType.put(x.termSymbol, b4 + 1)
-            case _ =>
-          })
+      tp.foreachPart(x => x match {
+        case TermRef(NoPrefix, _) =>
+          val b4 = timesUsedAsType.getOrElseUpdate(x.termSymbol, 0)
+          timesUsedAsType.put(x.termSymbol, b4 + 1)
+        case _ =>
+      })
     }
     def doVisit(tree: Tree, used: mutable.HashMap[Symbol, Int]): Unit = tree match {
       case valdef: ValDef if !valdef.symbol.is(Param | Mutable | Module | Lazy) &&
@@ -1237,8 +1237,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
       case valdef: ValDef => visitType(valdef.symbol.info)
       case t: DefDef      => visitType(t.symbol.info)
-      case t: Typed       =>
-        visitType(t.tpt.tpe)
+      case t: Typed       => visitType(t.tpt.tpe)
       case t: TypeApply   => t.args.foreach(x => visitType(x.tpe))
       case t: RefTree =>
         val b4 = used.getOrElseUpdate(t.symbol, 0)

compiler/test/dotty/tools/dotc/SimplifyTests.scala

@@ -20,23 +20,23 @@ class DottyBytecodeOptimisedTest extends DottyBytecodeTest {
 }
 
 trait SimplifyEquivalences { self: DottyBytecodeTest =>
-  def check(expr1: String, expr2: String, shared: String = ""): Unit = {
+  def check(source: String, expected: String, shared: String = ""): Unit = {
     import ASMConverters._
-    val source =
+    val src =
       s"""
       $shared
       |class A {
       |  def main(): Unit = {
-            $expr1
+            $source
       |  }
       |}
       |class B {
       |  def main(): Unit = {
-            $expr2
+            $expected
       |  }
       |}
       """.stripMargin
-    checkBCode(source) { dir =>
+    checkBCode(src) { dir =>
       def instructions(clazz: String): List[Instruction] = {
         val clsIn   = dir.lookupName(s"$clazz.class", directory = false).input
         val clsNode = loadClassNode(clsIn)
@@ -46,9 +46,9 @@ trait SimplifyEquivalences { self: DottyBytecodeTest =>
       val B = instructions("B")
       val diff = diffInstructions(A, B)
       if (this.isInstanceOf[DottyBytecodeOptimisedTest])
-        assert(A == B, s"Bytecode wasn't same:\n$diff")
+        assert(A == B, s"Bytecode doesn't match: (lhs = source, rhs = expected) \n$diff")
       else
-        assert(A != B, s"Bytecode was the same:\n$diff")
+        assert(A != B, s"Same Bytecodes without -optimise: you are testing the wrong thing!")
     }
   }
 
@@ -62,9 +62,9 @@ trait SimplifyEquivalences { self: DottyBytecodeTest =>
 
   @Test def inlineCaseIntrinsicsDottyApply =
     check(
-      expr1  = "CC.apply(1, 2)",
-      expr2  = "new CC(1, 2)",
-      shared = "case class CC(i: Int, j: Int)")
+      source   = "CC.apply(1, 2)",
+      expected = "new CC(1, 2)",
+      shared   = "case class CC(i: Int, j: Int)")
 
   @Test def inlineCaseIntrinsicsScalacApply =
     check("::.apply(1, Nil)", "new ::(1, Nil)")