Fix #2964: Refresh names for anonymous classes

Author: nicolasstucki

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -100,7 +100,8 @@ class Compiler {
            new ElimStaticThis,      // Replace `this` references to static objects by global identifiers
            new Flatten,             // Lift all inner classes to package scope
            new RestoreScopes),      // Repair scopes rendered invalid by moving definitions in prior phases of the group
-      List(new TransformWildcards,  // Replace wildcards with default values
+      List(new LiftedClasses,       // Renames lifted classes to local numbering scheme
+           new TransformWildcards,  // Replace wildcards with default values
            new MoveStatics,         // Move static methods to companion classes
            new ExpandPrivate,       // Widen private definitions accessed from nested classes
            new SelectStatic,        // get rid of selects that would be compiled into GetStatic

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

@@ -0,0 +1,47 @@
+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}
+
+/** Renames lifted classes to local numbering scheme */
+class LiftedClasses extends MiniPhaseTransform with SymTransformer { thisTransformer =>
+
+  override def phaseName = "liftedClasses"
+
+  override def runsAfterGroupsOf: Set[Class[_ <: Phases.Phase]] = Set(classOf[Flatten])
+
+  def transformSym(ref: SymDenotation)(implicit ctx: Context): SymDenotation =
+    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
+
+  private def needsRefresh(sym: Symbol)(implicit ctx: Context): Boolean =
+    sym.isClass && !sym.is(Package) && 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 = {
+    // TODO: Refresh names not only based on their full name?
+    //       Include package to distinguish <class>$anon from <pack>.<class>$anon
+    val name = sym.name
+    val newName = (name.firstPart.toString + str.NAME_JOIN + name.lastPart).toTermName
+
+    var freshName = UniqueName.fresh(newName).toTypeName
+    if (name.toSimpleName.endsWith(str.MODULE_SUFFIX))
+      freshName = (freshName + str.MODULE_SUFFIX).toTypeName
+
+    freshName
+  }
+}

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

@@ -5,6 +5,7 @@ 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:
@@ -16,6 +17,8 @@ class TransformWildcards extends MiniPhaseTransform with IdentityDenotTransforme
 
   override def phaseName = "transformWildcards"
 
+  override def runsAfter: Set[Class[_ <: Phases.Phase]] = Set(classOf[LiftedClasses])
+
   override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = {
     tree match {
       case vDef: ValDef => assert(!tpd.isWildcardArg(vDef.rhs))

tests/run/i2738.check

@@ -3,6 +3,6 @@ bar$1
 foo
 bar$2
 baz
-Test$qux$2$
+Test$qux$1$
 baz
-Test$qux$4$
+Test$qux$2$

tests/run/i2964.check

@@ -0,0 +1,4 @@
+class Foo$$anon$1
+class Bar$$anon$1
+class Bar$$anon$2
+class Baz$$anon$1

tests/run/i2964.scala

@@ -0,0 +1,27 @@
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    new Foo
+    new Bar
+    new Baz
+  }
+}
+
+class Foo {
+  new Object {
+    println(this.getClass) // Foo$$anon$1
+  }
+}
+class Bar {
+  new Object {
+    println(this.getClass) // Bar$$anon$1
+  }
+  new Object {
+    println(this.getClass) // Bar$$anon$2
+  }
+}
+class Baz {
+  new Object {
+    println(this.getClass) // Baz$$anon$1
+  }
+}

tests/run/i2964b.check

@@ -0,0 +1,4 @@
+class Foo$$anon$1
+class Bar$$anon$1
+class Bar$$anon$2
+class Baz$$anon$1

tests/run/i2964b.scala

@@ -0,0 +1,27 @@
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    Foo
+    Bar
+    Baz
+  }
+}
+
+object Foo {
+  new Object {
+    println(this.getClass) // Foo$$anon$1
+  }
+}
+object Bar {
+  new Object {
+    println(this.getClass) // Bar$$anon$1
+  }
+  new Object {
+    println(this.getClass) // Bar$$anon$2
+  }
+}
+object Baz {
+  new Object {
+    println(this.getClass) // Baz$$anon$1
+  }
+}

tests/run/i2964c.check

@@ -0,0 +1,4 @@
+class Foo$Inner$1
+class Bar$Inner$1
+class Bar$Inner$2
+class Baz$Inner$1

tests/run/i2964c.scala

@@ -0,0 +1,41 @@
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    new Foo().foo
+    new Bar().bar
+    new Bar().bar2
+    new Baz().baz
+  }
+}
+
+class Foo {
+  def foo: Unit = {
+    class Inner {
+      println(this.getClass)
+    }
+    new Inner
+  }
+}
+class Bar {
+  def bar: Unit = {
+    class Inner {
+      println(this.getClass)
+    }
+    new Inner
+  }
+
+  def bar2: Unit = {
+    class Inner {
+      println(this.getClass)
+    }
+    new Inner
+  }
+}
+class Baz {
+  def baz: Unit = {
+    class Inner {
+      println(this.getClass)
+    }
+    new Inner
+  }
+}

tests/run/i2964d.check

@@ -0,0 +1,4 @@
+class Foo$Inner$1$
+class Bar$Inner$1$
+class Bar$Inner$2$
+class Baz$Inner$1$

tests/run/i2964d.scala

@@ -0,0 +1,41 @@
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    new Foo().foo
+    new Bar().bar
+    new Bar().bar2
+    new Baz().baz
+  }
+}
+
+class Foo {
+  def foo: Unit = {
+    object Inner {
+      println(this.getClass)
+    }
+    Inner
+  }
+}
+class Bar {
+  def bar: Unit = {
+    object Inner {
+      println(this.getClass)
+    }
+    Inner
+  }
+
+  def bar2: Unit = {
+    object Inner {
+      println(this.getClass)
+    }
+    Inner
+  }
+}
+class Baz {
+  def baz: Unit = {
+    object Inner {
+      println(this.getClass)
+    }
+    Inner
+  }
+}