Elim ElimWildcardIdents

Instead of cleaning up, generate sensical code in the first place. This is shorter and
(I would argue) clearer, and also has the advantage that some initializing assignments
are not generated at all.

Author: odersky

src/dotty/tools/dotc/Compiler.scala

@@ -71,7 +71,6 @@ class Compiler {
       List(new LambdaLift,   // in this mini-phase block scopes are incorrect. No phases that rely on scopes should be here
            new Flatten,
            new ElimStaticThis,
-           new ElimWildcardIdents,
            new RestoreScopes),
       List(/*new PrivateToStatic,*/
            new ExpandPrivate,

src/dotty/tools/dotc/ast/tpd.scala

@@ -723,6 +723,12 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     def ensureConforms(tp: Type)(implicit ctx: Context): Tree =
       if (tree.tpe <:< tp) tree else asInstance(tp)
 
+    /** If inititializer tree is `_', the default value of its type,
+     *  otherwise the tree itself.
+     */
+    def wildcardToDefault(implicit ctx: Context) =
+      if (isWildcardArg(tree)) defaultValue(tree.tpe) else tree
+
     /** `this && that`, for boolean trees `this`, `that` */
     def and(that: Tree)(implicit ctx: Context): Tree =
       tree.select(defn.Boolean_&&).appliedTo(that)

src/dotty/tools/dotc/transform/ElimWildcardIdents.scala

@@ -146,8 +146,8 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
 
     def mkNonThreadSafeDef(target: Tree, flag: Tree, rhs: Tree)(implicit ctx: Context) = {
       val setFlag = flag.becomes(Literal(Constants.Constant(true)))
-      val setTarget = target.becomes(rhs)
-      val init = Block(List(setFlag, setTarget), target.ensureApplied)
+      val setTargets = if (isWildcardArg(rhs)) Nil else target.becomes(rhs) :: Nil
+      val init = Block(setFlag :: setTargets, target.ensureApplied)
       If(flag.ensureApplied, target.ensureApplied, init)
     }
 

src/dotty/tools/dotc/transform/LazyVals.scala

@@ -55,8 +55,9 @@ import Decorators._
     lazy val field = sym.field.orElse(newField).asTerm
     if (sym.is(Accessor, butNot = NoFieldNeeded))
       if (sym.isGetter) {
-        tree.rhs.changeOwnerAfter(sym, field, thisTransform)
-        val fieldDef = transformFollowing(ValDef(field, tree.rhs))
+        var rhs = tree.rhs.changeOwnerAfter(sym, field, thisTransform)
+        if (isWildcardArg(rhs)) rhs = EmptyTree
+        val fieldDef = transformFollowing(ValDef(field, rhs))
         val getterDef = cpy.DefDef(tree)(rhs = transformFollowingDeep(ref(field)))
         Thicket(fieldDef, getterDef)
       }

src/dotty/tools/dotc/transform/Memoize.scala

@@ -118,7 +118,7 @@ class Mixin extends MiniPhaseTransform with SymTransformer { thisTransform =>
           val isym = initializer(vsym)
           val rhs = Block(
             initBuf.toList.map(_.changeOwner(impl.symbol, isym)),
-            stat.rhs.changeOwner(vsym, isym))
+            stat.rhs.changeOwner(vsym, isym).wildcardToDefault)
           initBuf.clear()
           cpy.DefDef(stat)(rhs = EmptyTree) :: DefDef(isym, rhs) :: Nil
         case stat: DefDef if stat.symbol.isSetter =>