Run CompleteJavaEnums after erasure

CompleteJavaEnums changes some signatures (it adds extra constructor
parameters to classes extending java.lang.Enum), so it is not allowed to
run before Erasure (this is enforced by the check added in TreeChecker
in the previous commit).

Moving CompleteJavaEnums after Erasure required one change, prior to
this commit, constructor parameter were added to enum cases in two
different places:
- `def $new(...) = { new E { ... } }` was handled by transformDefDef
- `val Foo = new E { ... }` was handled by transformTemplate

It turns out that we can just let transformTemplate handle both cases,
this simplifies the code and means that the Mixin phase can run after
CompleteJavaEnums in the same group and see the transformed
constructors.

Author: smarter

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

@@ -61,8 +61,7 @@ class Compiler {
          new CheckStatic,            // Check restrictions that apply to @static members
          new BetaReduce,             // Reduce closure applications
          new init.Checker) ::        // Check initialization of objects
-    List(new CompleteJavaEnums,      // Fill in constructors for Java enums
-         new ElimRepeated,           // Rewrite vararg parameters and arguments
+    List(new ElimRepeated,           // Rewrite vararg parameters and arguments
          new ExpandSAMs,             // Expand single abstract method closures to anonymous classes
          new ProtectedAccessors,     // Add accessors for protected members
          new ExtensionMethods,       // Expand methods of value classes with extension methods
@@ -101,6 +100,7 @@ class Compiler {
          new ArrayApply,             // Optimize `scala.Array.apply([....])` and `scala.Array.apply(..., [....])` into `[...]`
          new ElimPolyFunction,       // Rewrite PolyFunction subclasses to FunctionN subclasses
          new TailRec,                // Rewrite tail recursion to loops
+         new CompleteJavaEnums,      // Fill in constructors for Java enums
          new Mixin,                  // Expand trait fields and trait initializers
          new LazyVals,               // Expand lazy vals
          new Memoize,                // Add private fields to getters and setters

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

@@ -77,38 +77,14 @@ class CompleteJavaEnums extends MiniPhase with InfoTransformer { thisPhase =>
       case p => p
     }
 
-  /** 1. If this is a constructor of a enum class that extends, add $name and $ordinal parameters to it.
-   *
-   *  2. If this is a $new method that creates simple cases, pass $name and $ordinal parameters
-   *     to the enum superclass. The $new method looks like this:
-   *
-   *       def $new(..., ordinal: Int, name: String) = {
-   *         class $anon extends E(...) { ... }
-   *         new $anon
-   *       }
-   *
-   *     After the transform it is expanded to
-   *
-   *       def $new(..., ordinal: Int, name: String) = {
-   *         class $anon extends E(..., name, ordinal) { ... }
-   *         new $anon
-   *       }
-   */
+  /** If this is a constructor of a enum class that extends, add $name and $ordinal parameters to it. */
   override def transformDefDef(tree: DefDef)(implicit ctx: Context): DefDef = {
     val sym = tree.symbol
     if (sym.isConstructor && sym.owner.derivesFromJavaEnum)
       val tree1 = cpy.DefDef(tree)(
         vparamss = tree.vparamss.init :+ (tree.vparamss.last ++ addedParams(sym, Param)))
       sym.setParamssFromDefs(tree1.tparams, tree1.vparamss)
       tree1
-    else if (sym.name == nme.DOLLAR_NEW && sym.owner.linkedClass.derivesFromJavaEnum) {
-      val Block((tdef @ TypeDef(tpnme.ANON_CLASS, templ: Template)) :: Nil, call) = tree.rhs
-      val args = tree.vparamss.last.takeRight(2).map(param => ref(param.symbol)).reverse
-      val templ1 = cpy.Template(templ)(
-        parents = addEnumConstrArgs(sym.owner.linkedClass, templ.parents, args))
-      cpy.DefDef(tree)(
-        rhs = cpy.Block(tree.rhs)(cpy.TypeDef(tdef)(tdef.name, templ1) :: Nil, call))
-    }
     else tree
   }
 
@@ -159,7 +135,8 @@ class CompleteJavaEnums extends MiniPhase with InfoTransformer { thisPhase =>
         parents = addEnumConstrArgs(defn.JavaEnumClass, templ.parents, addedSyms.map(ref)),
         body = params ++ addedDefs ++ addedForwarders ++ rest)
     }
-    else if (cls.isAnonymousClass && cls.owner.isAllOf(EnumCase) && cls.owner.owner.linkedClass.derivesFromJavaEnum) {
+    else if (cls.isAnonymousClass && ((cls.owner.name eq nme.DOLLAR_NEW) || cls.owner.isAllOf(EnumCase)) &&
+             cls.owner.owner.linkedClass.derivesFromJavaEnum) {
       def rhsOf(name: TermName) =
         templ.body.collect {
           case mdef: DefDef if mdef.name == name => mdef.rhs

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

@@ -112,7 +112,10 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase =>
   override def relaxedTypingInGroup: Boolean = true
     // Because it changes number of parameters in trait initializers
 
-  override def runsAfter: Set[String] = Set(Erasure.name)
+  override def runsAfter: Set[String] = Set(
+    Erasure.name,
+    CompleteJavaEnums.name // This phase changes constructor parameters which Mixin translates into super-calls
+  )
 
   override def changesMembers: Boolean = true  // the phase adds implementions of mixin accessors