Methods to derive ValDefs and Templates.

It's a lot like the last one.  I also found trees being
duplicated before being sent to the tree copier.  Looks like
xerox has gotten a mole in here.  Trust no one.

Author: paulp

src/compiler/scala/reflect/internal/Trees.scala

@@ -272,7 +272,18 @@ trait Trees extends api.Trees { self: SymbolTable =>
     override def traverse(t: Tree) {
       if (t != EmptyTree && t.pos == NoPosition) {
         t.setPos(pos)
-        super.traverse(t) // TODO: bug? shouldn't the traverse be outside of the if?
+        super.traverse(t)   // TODO: bug? shouldn't the traverse be outside of the if?
+        // @PP: it's pruning whenever it encounters a node with a
+        // position, which I interpret to mean that (in the author's
+        // mind at least) either the children of a positioned node will
+        // already be positioned, or the children of a positioned node
+        // do not merit positioning.
+        //
+        // Whatever the author's rationale, it does seem like a bad idea
+        // to press on through a positioned node to find unpositioned
+        // children beneath it and then to assign whatever happens to
+        // be in `pos` to such nodes. There are supposed to be some
+        // position invariants which I can't imagine surviving that.
       }
     }
   }

src/compiler/scala/tools/nsc/ast/Trees.scala

@@ -79,16 +79,16 @@ trait Trees extends reflect.internal.Trees { self: Global =>
     val (edefs, rest) = body span treeInfo.isEarlyDef
     val (evdefs, etdefs) = edefs partition treeInfo.isEarlyValDef
     val gvdefs = evdefs map {
-      case vdef @ ValDef(mods, name, tpt, rhs) =>
-        treeCopy.ValDef(
-          vdef.duplicate, mods, name,
-          atPos(focusPos(vdef.pos)) { TypeTree() setOriginal tpt setPos focusPos(tpt.pos) }, // atPos in case
-          EmptyTree)
-    }
-    val lvdefs = evdefs map {
-      case vdef @ ValDef(mods, name, tpt, rhs) =>
-        treeCopy.ValDef(vdef, Modifiers(PRESUPER), name, tpt, rhs)
+      case vdef @ ValDef(_, _, tpt, _) => copyValDef(vdef)(
+        // !!! I know "atPos in case" wasn't intentionally planted to
+        // add an air of mystery to this file, but it is the sort of
+        // comment which only its author could love.
+        tpt = atPos(focusPos(vdef.pos))(TypeTree() setOriginal tpt setPos focusPos(tpt.pos)), // atPos in case
+        rhs = EmptyTree
+      )
     }
+    val lvdefs = evdefs collect { case vdef: ValDef => copyValDef(vdef)(mods = Modifiers(PRESUPER)) }
+
     val constrs = {
       if (constrMods hasFlag TRAIT) {
         if (body forall treeInfo.isInterfaceMember) List()
@@ -108,13 +108,11 @@ trait Trees extends reflect.internal.Trees { self: Global =>
             DefDef(constrMods, nme.CONSTRUCTOR, List(), vparamss1, TypeTree(), Block(lvdefs ::: List(superCall), Literal(Constant())))))
       }
     }
-    // println("typed template, gvdefs = "+gvdefs+", parents = "+parents+", constrs = "+constrs)
     constrs foreach (ensureNonOverlapping(_, parents ::: gvdefs))
-    // vparamss2 are used as field definitions for the class. remove defaults
-    val vparamss2 = vparamss map (vps => vps map { vd =>
-      treeCopy.ValDef(vd, vd.mods &~ DEFAULTPARAM, vd.name, vd.tpt, EmptyTree)
-    })
-    Template(parents, self, gvdefs ::: vparamss2.flatten ::: constrs ::: etdefs ::: rest)
+    // Field definitions for the class - remove defaults.
+    val fieldDefs = vparamss.flatten map (vd => copyValDef(vd)(mods = vd.mods &~ DEFAULTPARAM, rhs = EmptyTree))
+
+    Template(parents, self, gvdefs ::: fieldDefs ::: constrs ::: etdefs ::: rest)
   }
 
   /** Construct class definition with given class symbol, value parameters,

src/compiler/scala/tools/nsc/javac/JavaParsers.scala

@@ -653,10 +653,7 @@ trait JavaParsers extends ast.parser.ParsersCommon with JavaScanners {
     // leaves auxiliary constructors unable to access members of the companion object
     // as unqualified identifiers.
     def addCompanionObject(statics: List[Tree], cdef: ClassDef): List[Tree] = {
-      def implWithImport(importStmt: Tree) = {
-        import cdef.impl._
-        treeCopy.Template(cdef.impl, parents, self, importStmt :: body)
-      }
+      def implWithImport(importStmt: Tree) = deriveTemplate(cdef.impl)(importStmt :: _)
       // if there are no statics we can use the original cdef, but we always
       // create the companion so import A._ is not an error (see ticket #1700)
       val cdefNew =

src/compiler/scala/tools/nsc/transform/Constructors.scala

@@ -175,7 +175,7 @@ abstract class Constructors extends Transform with ast.TreeDSL {
               else if (stat.symbol.isConstructor) auxConstructorBuf += stat
               else defBuf += stat
           }
-        case ValDef(mods, name, tpt, rhs) =>
+        case ValDef(_, _, _, rhs) =>
           // val defs with constant right-hand sides are eliminated.
           // for all other val defs, an empty valdef goes into the template and
           // the initializer goes as an assignment into the constructor
@@ -188,7 +188,7 @@ abstract class Constructors extends Transform with ast.TreeDSL {
               (if (canBeMoved(stat)) constrPrefixBuf else constrStatBuf) += mkAssign(
                 stat.symbol, rhs1)
             }
-            defBuf += treeCopy.ValDef(stat, mods, name, tpt, EmptyTree)
+            defBuf += deriveValDef(stat)(_ => EmptyTree)
           }
         case ClassDef(_, _, _, _) =>
           // classes are treated recursively, and left in the template
@@ -560,8 +560,7 @@ abstract class Constructors extends Transform with ast.TreeDSL {
         clazz.info.decls unlink sym
 
       // Eliminate all field definitions that can be dropped from template
-      treeCopy.Template(impl, impl.parents, impl.self,
-        defBuf.toList filter (stat => mustbeKept(stat.symbol)))
+      deriveTemplate(impl)(_ => defBuf.toList filter (stat => mustbeKept(stat.symbol)))
     } // transformClassTemplate
 
     override def transform(tree: Tree): Tree =

src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala

@@ -468,8 +468,10 @@ abstract class ExplicitOuter extends InfoTransform
             }
           }
           super.transform(
-            treeCopy.Template(tree, parents, self,
-                          if (newDefs.isEmpty) decls else decls ::: newDefs.toList)
+            deriveTemplate(tree)(decls => 
+              if (newDefs.isEmpty) decls
+              else decls ::: newDefs.toList
+            )
           )
         case DefDef(_, _, _, vparamss, _, rhs) =>
           if (sym.isClassConstructor) {

src/compiler/scala/tools/nsc/transform/LambdaLift.scala

@@ -326,7 +326,7 @@ abstract class LambdaLift extends InfoTransform {
               lifted(MethodType(sym.info.params ::: addParams, sym.info.resultType)))
 
             copyDefDef(tree)(vparamss = List(vparams ++ freeParams))
-          case ClassDef(mods, name, tparams, impl @ Template(parents, self, body)) =>
+          case ClassDef(mods, name, tparams, impl) =>
             // Disabled attempt to to add getters to freeParams
             // this does not work yet. Problem is that local symbols need local names
             // and references to local symbols need to be transformed into
@@ -338,8 +338,7 @@ abstract class LambdaLift extends InfoTransform {
             //   DefDef(getter, rhs) setPos tree.pos setType NoType
             // }
             // val newDefs = if (sym.isTrait) freeParams ::: (ps map paramGetter) else freeParams
-            treeCopy.ClassDef(tree, mods, name, tparams,
-                              treeCopy.Template(impl, parents, self, body ::: freeParams))
+            treeCopy.ClassDef(tree, mods, name, tparams, deriveTemplate(impl)(_ ::: freeParams))
         }
       case None =>
         tree
@@ -481,15 +480,14 @@ abstract class LambdaLift extends InfoTransform {
     /** Transform statements and add lifted definitions to them. */
     override def transformStats(stats: List[Tree], exprOwner: Symbol): List[Tree] = {
       def addLifted(stat: Tree): Tree = stat match {
-        case ClassDef(mods, name, tparams, impl @ Template(parents, self, body)) =>
+        case ClassDef(mods, name, tparams, impl) =>
           val lifted = liftedDefs get stat.symbol match {
             case Some(xs) => xs reverseMap addLifted
             case _        => log("unexpectedly no lifted defs for " + stat.symbol) ; Nil
           }
-          val result = treeCopy.ClassDef(
-            stat, mods, name, tparams, treeCopy.Template(impl, parents, self, body ::: lifted))
-          liftedDefs -= stat.symbol
-          result
+          try treeCopy.ClassDef(stat, mods, name, tparams, deriveTemplate(impl)(_ ::: lifted))
+          finally liftedDefs -= stat.symbol
+
         case DefDef(_, _, _, _, _, Block(Nil, expr)) if !stat.symbol.isConstructor =>
           deriveDefDef(stat)(_ => expr)
         case _ =>

src/compiler/scala/tools/nsc/transform/LazyVals.scala

@@ -93,7 +93,7 @@ abstract class LazyVals extends Transform with TypingTransformers with ast.TreeD
           deriveDefDef(tree)(_ => if (LocalLazyValFinder.find(res)) typed(addBitmapDefs(sym, res)) else res)
         }
 
-        case Template(parents, self, body) => atOwner(currentOwner) {
+        case Template(_, _, body) => atOwner(currentOwner) {
           val body1 = super.transformTrees(body)
           var added = false
           val stats =
@@ -105,8 +105,8 @@ abstract class LazyVals extends Transform with TypingTransformers with ast.TreeD
                   added = true
                   typed(addBitmapDefs(sym, stat))
                 } else stat
-              case ValDef(mods, name, tpt, rhs) =>
-                typed(treeCopy.ValDef(stat, mods, name, tpt, addBitmapDefs(stat.symbol, rhs)))
+              case ValDef(_, _, _, _) =>
+                typed(deriveValDef(stat)(addBitmapDefs(stat.symbol, _)))
               case _ =>
                 stat
             }
@@ -121,13 +121,14 @@ abstract class LazyVals extends Transform with TypingTransformers with ast.TreeD
                 })
                 toAdd0
             } else List()
-          treeCopy.Template(tree, parents, self, innerClassBitmaps ++ stats)
+          deriveTemplate(tree)(_ => innerClassBitmaps ++ stats)
         }
 
-        case ValDef(mods, name, tpt, rhs0) if (!sym.owner.isModule && !sym.owner.isClass) =>
-          val rhs = super.transform(rhs0)
-          treeCopy.ValDef(tree, mods, name, tpt,
-                  if (LocalLazyValFinder.find(rhs)) typed(addBitmapDefs(sym, rhs)) else rhs)
+        case ValDef(_, _, _, _) if !sym.owner.isModule && !sym.owner.isClass =>
+          deriveValDef(tree) { rhs0 => 
+            val rhs = super.transform(rhs0)
+            if (LocalLazyValFinder.find(rhs)) typed(addBitmapDefs(sym, rhs)) else rhs
+          }
 
         case l@LabelDef(name0, params0, ifp0@If(_, _, _)) if name0.startsWith(nme.WHILE_PREFIX) =>
           val ifp1 = super.transform(ifp0)

src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala

@@ -1480,21 +1480,22 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
               localTyper.typed(deriveDefDef(tree)(rhs => rhs))
           }
 
-        case ValDef(mods, name, tpt, rhs) if symbol.hasFlag(SPECIALIZED) && !symbol.isParamAccessor =>
+        case ValDef(_, _, _, _) if symbol.hasFlag(SPECIALIZED) && !symbol.isParamAccessor =>
           assert(body.isDefinedAt(symbol.alias), body)
-          val tree1 = treeCopy.ValDef(tree, mods, name, tpt, body(symbol.alias).duplicate)
+          val tree1 = deriveValDef(tree)(_ => body(symbol.alias).duplicate)
           debuglog("now typing: " + tree1 + " in " + tree.symbol.owner.fullName)
+
           val d = new Duplicator
-          val ValDef(mods1, name1, tpt1, rhs1) = d.retyped(
+          val newValDef = d.retyped(
             localTyper.context1.asInstanceOf[d.Context],
             tree1,
             symbol.alias.enclClass,
             symbol.enclClass,
             typeEnv(symbol.alias) ++ typeEnv(tree.symbol)
           )
-          val t = treeCopy.ValDef(tree1, mods1, name1, tpt1, transform(rhs1))
-          log("valdef " + tree + " -> " + t)
-          t
+          logResult("valdef " + tree + " -> ") {
+            deriveValDef(newValDef)(transform)
+          }
 
 //          val tree1 =
 //            treeCopy.ValDef(tree, mods, name, tpt,

src/compiler/scala/tools/nsc/transform/UnCurry.scala

@@ -620,13 +620,11 @@ abstract class UnCurry extends InfoTransform
          * In particular, this case will add:
          * - synthetic Java varargs forwarders for repeated parameters
          */
-        case Template(parents, self, body) =>
+        case Template(_, _, _) =>
           localTyper = typer.atOwner(tree, currentClass)
-          val tmpl = if (!forMSIL || forMSIL) {
-            treeCopy.Template(tree, parents, self, transformTrees(newMembers.toList) ::: body)
-          } else super.transform(tree).asInstanceOf[Template]
-          newMembers.clear
-          tmpl
+          try deriveTemplate(tree)(transformTrees(newMembers.toList) ::: _)
+          finally newMembers.clear()
+
         case dd @ DefDef(_, _, _, vparamss0, _, rhs0) =>
           val flatdd = copyDefDef(dd)(
             vparamss = List(vparamss0.flatten),

src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala

@@ -376,7 +376,7 @@ trait MethodSynthesis {
       override def keepClean = !mods.isParamAccessor
       override def derivedTree = (
         if (mods.isDeferred) EmptyTree
-        else treeCopy.ValDef(tree, mods | flagsExtra, name, tree.tpt, tree.rhs)
+        else copyValDef(tree)(mods = mods | flagsExtra, name = this.name)
       )
     }
     case class Param(tree: ValDef) extends DerivedFromValDef {