Eliminate `_' from rhs of ValDefs

Previously was only done for DefDefs. Caused backend failure.

Author: odersky

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

@@ -418,7 +418,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     Thicket(valdef, clsdef)
   }
 
-  def initValue(tpe: Types.Type)(implicit ctx: Context) = {
+  def defaultValue(tpe: Types.Type)(implicit ctx: Context) = {
     val tpw = tpe.widen
 
     if (tpw isRef defn.IntClass) Literal(Constant(0))

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

@@ -1,26 +1,14 @@
-package dotty.tools.dotc.transform
+package dotty.tools.dotc
+package transform
 
-import dotty.tools.dotc.transform.TreeTransforms.{TransformerInfo, TreeTransform, TreeTransformer, MiniPhaseTransform}
-import dotty.tools.dotc.ast.{untpd, tpd}
-import dotty.tools.dotc.core.Contexts.Context
-import scala.collection.mutable.ListBuffer
-import dotty.tools.dotc.core.{Scopes, Flags}
-import dotty.tools.dotc.core.Symbols.NoSymbol
-import scala.annotation.tailrec
-import dotty.tools.dotc.core._
+import TreeTransforms.{MiniPhaseTransform, TransformerInfo}
+import ast.tpd
+import ast.Trees._
+import core._
+import Contexts.Context
 import Symbols._
-import scala.Some
-import dotty.tools.dotc.transform.TreeTransforms.{NXTransformations, TransformerInfo, TreeTransform, TreeTransformer}
-import dotty.tools.dotc.core.Contexts.Context
-import scala.collection.mutable
-import dotty.tools.dotc.core.Names.Name
-import NameOps._
 import Types._
-import scala.collection.SortedSet
-import Decorators._
 import StdNames._
-import dotty.tools.dotc.util.Positions.Position
-import dotty.tools.dotc.config.JavaPlatform
 
 /**
  * Replace Ident("_") in tree with default values of corresponding type:
@@ -29,21 +17,21 @@ import dotty.tools.dotc.config.JavaPlatform
  *   classes: `null`
  */
 class ElimWildcardIdents extends MiniPhaseTransform {
-  import tpd._
+  import ast.tpd._
   def phaseName: String = "elimWildcardIdents"
 
-
-  override def transformDefDef(tree: tpd.DefDef)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = {
-    def stripBlocks(arg: Tree): Tree =  arg match {
-      case b: Block if b.stats.isEmpty => stripBlocks(b.expr)
-      case _ => arg
-    }
-    val b = stripBlocks(tree.rhs)
-    b match {
-      case x: Ident if (x.name == nme.WILDCARD && x.symbol.isClass) =>
-        tpd.DefDef(tree.symbol.asTerm, tpd.initValue(x.tpe))
+  def wildcardToDefaultValue(tree: Tree)(implicit ctx: Context) = {
+    def recur(x: Tree): Tree = x match {
+      case x: Ident if x.name == nme.WILDCARD && x.symbol.isClass => defaultValue(tree.tpe)
+      case Block(Nil, y) => recur(y)
       case _ => tree
     }
+    recur(tree)
   }
 
+  override def transformValDef(tree: tpd.ValDef)(implicit ctx: Context, info: TransformerInfo): tpd.Tree =
+    cpy.ValDef(tree)(rhs = wildcardToDefaultValue(tree.rhs))
+
+  override def transformDefDef(tree: tpd.DefDef)(implicit ctx: Context, info: TransformerInfo): tpd.Tree =
+    cpy.DefDef(tree)(rhs = wildcardToDefaultValue(tree.rhs))
 }

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

@@ -177,7 +177,7 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
           tpe, coord = x.symbol.coord
         ).entered
 
-        val containerTree = ValDef(containerSymbol, initValue(tpe))
+        val containerTree = ValDef(containerSymbol, defaultValue(tpe))
         if (x.tpe.isNotNull && tpe <:< defn.ObjectType) { // can use 'null' value instead of flag
           val slowPath = DefDef(x.symbol.asTerm, mkDefNonThreadSafeNonNullable(containerSymbol, x.rhs))
           Thicket(List(containerTree, slowPath))
@@ -234,7 +234,7 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
       val thiz = This(claz)(ctx.fresh.setOwner(claz))
 
       val resultSymbol = ctx.newSymbol(methodSymbol, lazyNme.result, containerFlags, tp)
-      val resultDef = ValDef(resultSymbol, initValue(tp))
+      val resultDef = ValDef(resultSymbol, defaultValue(tp))
 
       val retrySymbol = ctx.newSymbol(methodSymbol, lazyNme.retry, containerFlags, defn.BooleanType)
       val retryDef = ValDef(retrySymbol, Literal(Constants.Constant(true)))
@@ -332,7 +332,7 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
 
         val containerName = ctx.freshName(x.name ++ StdNames.nme.LAZY_LOCAL).toTermName
         val containerSymbol = ctx.newSymbol(claz, containerName, (x.mods &~ containerFlagsMask | containerFlags).flags, tpe, coord = x.symbol.coord).entered
-        val containerTree = ValDef(containerSymbol, initValue(tpe))
+        val containerTree = ValDef(containerSymbol, defaultValue(tpe))
 
         val offset =  ref(companion).ensureApplied.select(offsetSymbol)
         val getFlag = Select(ref(helperModule), lazyNme.RLazyVals.get)

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

@@ -18,7 +18,6 @@ class TraitConstructors extends MiniPhaseTransform with SymTransformer {
   import dotty.tools.dotc.ast.tpd._
   def phaseName: String = "traitConstructors"
 
-
   override def treeTransformPhase: Phase = this.phase
 
   def transformSym(sym: SymDenotation)(implicit ctx: Context): SymDenotation = {

test/dotc/tests.scala

@@ -137,7 +137,7 @@ class tests extends CompilerTest {
   @Test def neg_escapingRefs = compileFile(negDir, "escapingRefs", xerrors = 2)
   @Test def neg_instantiateAbstract = compileFile(negDir, "instantiateAbstract", xerrors = 8)
   @Test def neg_selfInheritance = compileFile(negDir, "selfInheritance", xerrors = 5)
-  
+
 
   @Test def run_all = runFiles(runDir)