Fix #3006: Refresh names for lifted methods

Author: nicolasstucki

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

@@ -1,17 +1,15 @@
 package dotty.tools.dotc.transform
 
-import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.core.DenotTransformers.SymTransformer
 import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.NameKinds._
 import dotty.tools.dotc.core.Names._
 import dotty.tools.dotc.core.Phases
-import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.core.SymDenotations.SymDenotation
 import dotty.tools.dotc.core.Symbols._
-import dotty.tools.dotc.transform.TreeTransforms.{MiniPhaseTransform, TransformerInfo}
+import dotty.tools.dotc.transform.TreeTransforms.MiniPhaseTransform
 
 /** Renames lifted classes to local numbering scheme */
 class RenameLifted extends MiniPhaseTransform with SymTransformer { thisTransformer =>
@@ -24,25 +22,21 @@ class RenameLifted extends MiniPhaseTransform with SymTransformer { thisTransfor
     if (needsRefresh(ref.symbol)) ref.copySymDenotation(name = refreshedName(ref.symbol))
     else ref
 
-  override def transformTypeDef(tree: tpd.TypeDef)(implicit ctx: Context, info: TransformerInfo): tpd.Tree =
-    if (needsRefresh(tree.symbol)) cpy.TypeDef(tree)(name = tree.symbol.name.asTypeName)
-    else tree
-
+  /** If the name of the symbol with a unique name needs to be refreshed
+   *    - if it is a lifted class
+   *    - if it is a lifted method
+   */
   private def needsRefresh(sym: Symbol)(implicit ctx: Context): Boolean =
-    sym.isClass && sym.name.is(UniqueName)
-
-  /* Makes a new unique name based on a unique name that was flatten */
-  private def refreshedName(sym: Symbol)(implicit ctx: Context): TypeName = {
-    val packName = sym.owner.fullName.toString
-    val name = sym.name
-    val newName = (packName + name.firstPart + str.NAME_JOIN + name.lastPart).toTermName
-
-    var freshName = UniqueName.fresh(newName).toTypeName
-    val prefix = if (sym.owner.isEmptyPackage) "$empty$" else packName
-    freshName = freshName.toString.substring(prefix.length).toTypeName
-    if (name.toSimpleName.endsWith(str.MODULE_SUFFIX))
-      freshName = (freshName + str.MODULE_SUFFIX).toTypeName
-
-    freshName
+    (sym.isClass || sym.is(Private | Method | JavaStatic)) && sym.name.is(UniqueName)
+
+  /** Refreshes the number of the name based on the full name of the symbol */
+  private def refreshedName(sym: Symbol)(implicit ctx: Context): Name = {
+    sym.name.rewrite {
+      case name: DerivedName if name.info.kind == UniqueName =>
+        val fullName = (sym.owner.fullName.toString + name.underlying).toTermName
+        val freshName = UniqueName.fresh(fullName)
+        val info = freshName.asInstanceOf[DerivedName].info
+        DerivedName(name.underlying, info)
+    }
   }
 }

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

@@ -5,7 +5,6 @@ import TreeTransforms._
 import core.DenotTransformers._
 import core.Contexts._
 import ast.tpd
-import dotty.tools.dotc.core.Phases
 
 /** This phase transforms wildcards in valdefs with their default value.
   *  In particular for every valdef that is declared:
@@ -17,8 +16,6 @@ class TransformWildcards extends MiniPhaseTransform with IdentityDenotTransforme
 
   override def phaseName = "transformWildcards"
 
-  override def runsAfter: Set[Class[_ <: Phases.Phase]] = Set(classOf[RenameLifted])
-
   override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = {
     tree match {
       case vDef: ValDef => assert(!tpd.isWildcardArg(vDef.rhs))

tests/run/i2738.check

@@ -1,7 +1,7 @@
 foo
-bar$1
-foo
 bar$2
+foo
+bar$1
 baz
 Test$qux$1$
 baz

tests/run/i3006.check

@@ -0,0 +1,5 @@
+f$3
+f$2
+f$1
+f$2
+f$1

tests/run/i3006.scala

@@ -0,0 +1,35 @@
+class Foo {
+  def foo() = {
+    def f() = println(Thread.currentThread.getStackTrace.apply(1).getMethodName)
+    f()
+  }
+  def bar() = {
+    def f() = println(Thread.currentThread.getStackTrace.apply(1).getMethodName)
+    f()
+  }
+  def baz() = {
+    def f() = println(Thread.currentThread.getStackTrace.apply(1).getMethodName)
+    f()
+  }
+}
+
+class Bar {
+  def foo() = {
+    def f() = println(Thread.currentThread.getStackTrace.apply(1).getMethodName)
+    f()
+  }
+  def bar() = {
+    def f() = println(Thread.currentThread.getStackTrace.apply(1).getMethodName)
+    f()
+  }
+}
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    new Foo().foo()
+    new Foo().bar()
+    new Foo().baz()
+    new Bar().foo()
+    new Bar().bar()
+  }
+}

tests/run/i3006b.check

@@ -0,0 +1,3 @@
+Foo$$init$$$bar$2
+Foo$$init$$$bar$1
+Bar$$init$$$bar$1

tests/run/i3006b.scala

@@ -0,0 +1,35 @@
+class Foo(i: Int) {
+  def this() = this({
+    def bar() = {
+      println(Thread.currentThread.getStackTrace.apply(1).getMethodName)
+      5
+    }
+    bar()
+  })
+
+  def this(i: String) = this({
+    def bar() = {
+      println(Thread.currentThread.getStackTrace.apply(1).getMethodName)
+      5
+    }
+    bar()
+  })
+}
+
+class Bar(i: Int) {
+  def this() = this({
+    def bar() = {
+      println(Thread.currentThread.getStackTrace.apply(1).getMethodName)
+      5
+    }
+    bar()
+  })
+}
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    new Foo()
+    new Foo("")
+    new Bar()
+  }
+}