Reuse wildcardToDefault

Author: biboudis

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

@@ -95,9 +95,9 @@ class Compiler {
                                        // Note: in this mini-phase block scopes are incorrect. No phases that rely on scopes should be here
            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
-           new TransformWildcards), // Replace wildcards with default values
-      List(new MoveStatics,         // Move static methods to companion classes
+           new RestoreScopes),       // Repair scopes rendered invalid by moving definitions in prior phases of the group
+      List(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
            new CollectEntryPoints,  // Find classes with main methods

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

@@ -4,45 +4,27 @@ package transform
 import TreeTransforms._
 import core.DenotTransformers._
 import core.Contexts._
-import ast.Trees._
 import ast.tpd
-import core.Constants.Constant
-import core.StdNames._
-import core.Symbols._
-
 
+/** This phase transforms wildcards in valdefs with their default value.
+  *  In particular for every valdef that is declared:
+  *    `val x : T = _` to `val x : T = <zero of T>`
+  *
+  */
 class TransformWildcards extends MiniPhaseTransform with IdentityDenotTransformer { thisTransform =>
   import tpd._
 
   override def phaseName = "transformWildcards"
 
   override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = {
     tree match {
-      case ValDef(_, _, Ident(name)) => assert(name ne nme.WILDCARD)
+      case vDef: ValDef => assert(!tpd.isWildcardArg(vDef.rhs))
       case _ =>
     }
   }
 
   override def transformValDef(tree: ValDef)(implicit ctx: Context, info: TransformerInfo): Tree = {
-    tree.rhs match {
-      case Ident(nme.WILDCARD) =>
-        val literal = defaultValueLiteral(tree)
-        cpy.ValDef(tree)(rhs = literal)
-      case _ => tree
-    }
-  }
-
-  def defaultValueLiteral(tree: ValDef)(implicit ctx: Context) = {
-    val t = tree.rhs.tpe.widenDealias.classSymbol
-
-    if (t eq defn.DoubleClass) Literal(Constant(0.0d))
-    else if (t eq defn.IntClass) Literal(Constant(0))
-    else if (t eq defn.CharClass) Literal(Constant('\u0000'))
-    else if (t eq defn.ByteClass) Literal(Constant(0: Byte))
-    else if (t eq defn.LongClass) Literal(Constant(0L))
-    else if (t eq defn.FloatClass) Literal(Constant(0f))
-    else if (t eq defn.UnitClass) Literal(Constant(()))
-    else if (t eq defn.BooleanClass) Literal(Constant(false))
-    else Literal(Constant(null))
+    if (ctx.owner.isClass) tree
+    else cpy.ValDef(tree)(rhs = tree.rhs.wildcardToDefault)
   }
-}
+}

tests/pos/i2468.scala

@@ -24,4 +24,4 @@ object Test {
   }
 
   class D(x: Int) extends AnyVal
-}
+}