Fix #2468: Replace wildcards in a mini-phase

Author: biboudis

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

@@ -95,7 +95,8 @@ 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 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 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/TransformWildcards.scala

@@ -0,0 +1,48 @@
+package dotty.tools.dotc
+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._
+
+
+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 _ =>
+    }
+  }
+
+  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))
+  }
+}

tests/pos/i2468.scala

@@ -0,0 +1,27 @@
+
+object Test {
+
+  class A {
+    private[this] var x: String = _
+  }
+
+  class B {
+    private[this] var x: String = _
+    x = "foo"
+  }
+
+  class C {
+    private[this] var x1: Int = _
+    private[this] var x2: Unit = _
+    private[this] var x3: Char = _
+    private[this] var x4: Boolean = _
+    private[this] var x5: Float = _
+    private[this] var x6: Double = _
+    private[this] var x7: Char = _
+    private[this] var x8: Byte = _
+    private[this] var x9: AnyVal = _
+    private[this] var x10: D = _
+  }
+
+  class D(x: Int) extends AnyVal
+}