Add/unpickling

src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -295,7 +295,7 @@ class DottyBackendInterface()(implicit ctx: Context) extends BackendInterface{
     val t = new TreeTraverser {
       var outerRhs: Tree = tree
 
-      def traverse(tree: tpd.Tree): Unit = tree match {
+      def traverse(tree: tpd.Tree)(implicit ctx: Context): Unit = tree match {
         case t: DefDef =>
           if (t.symbol is Flags.Label)
             res.put(outerRhs, t :: res.getOrElse(outerRhs, Nil))

src/dotty/tools/dotc/CompilationUnit.scala

@@ -13,4 +13,6 @@ class CompilationUnit(val source: SourceFile) {
   var tpdTree: tpd.Tree = tpd.EmptyTree
 
   def isJava = source.file.name.endsWith(".java")
+
+  var pickled: Array[Byte] = Array()
 }

src/dotty/tools/dotc/Compiler.scala

@@ -41,10 +41,10 @@ class Compiler {
       List(new FirstTransform,
            new SyntheticMethods),
       List(new SuperAccessors),
-      //List(new Pickler), // Pickler needs to come last in a group since it should not pickle trees generated later
+      List(new Pickler), // Pickler needs to come last in a group since it should not pickle trees generated later
       List(new RefChecks,
            new ElimRepeated,
-           new ElimLocals,
+           new NormalizeFlags,
            new ExtensionMethods),
       List(new TailRec), // TailRec needs to be in its own group for now.
                          // Otherwise it produces -Ycheck incorrect code for

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

@@ -218,7 +218,7 @@ object desugar {
 
   /** The expansion of a class definition. See inline comments for what is involved */
   def classDef(cdef: TypeDef)(implicit ctx: Context): Tree = {
-    val TypeDef(name, impl @ Template(constr0, parents, self, body)) = cdef
+    val TypeDef(name, impl @ Template(constr0, parents, self, _)) = cdef
     val mods = cdef.mods
 
     val (constr1, defaultGetters) = defDef(constr0, isPrimaryConstructor = true) match {
@@ -242,7 +242,7 @@ object desugar {
     val constr = cpy.DefDef(constr1)(tparams = constrTparams, vparamss = constrVparamss)
 
     // Add constructor type parameters to auxiliary constructors
-    val normalizedBody = body map {
+    val normalizedBody = impl.body map {
       case ddef: DefDef if ddef.name.isConstructorName =>
         cpy.DefDef(ddef)(tparams = constrTparams)
       case stat =>
@@ -342,7 +342,10 @@ object desugar {
     val companions =
       if (mods is Case) {
         val parent =
-          if (constrTparams.nonEmpty || constrVparamss.length > 1) anyRef
+          if (constrTparams.nonEmpty || 
+              constrVparamss.length > 1 || 
+              mods.is(Abstract) || 
+              constr.mods.is(Private)) anyRef
             // todo: also use anyRef if constructor has a dependent method type (or rule that out)!
           else (constrVparamss :\ classTypeRef) ((vparams, restpe) => Function(vparams map (_.tpt), restpe))
         val applyMeths =
@@ -425,10 +428,10 @@ object desugar {
       val modul = ValDef(name, clsRef, New(clsRef, Nil))
         .withMods(mods | ModuleCreationFlags)
         .withPos(mdef.pos)
-      val ValDef(selfName, selfTpt, selfRhs) = tmpl.self
+      val ValDef(selfName, selfTpt, _) = tmpl.self
       val selfMods = tmpl.self.mods
       if (!selfTpt.isEmpty) ctx.error("object definition may not have a self type", tmpl.self.pos)
-      val clsSelf = ValDef(selfName, SingletonTypeTree(Ident(name)), selfRhs)
+      val clsSelf = ValDef(selfName, SingletonTypeTree(Ident(name)), tmpl.self.rhs)
         .withMods(selfMods)
         .withPos(tmpl.self.pos orElse tmpl.pos.startPos)
       val clsTmpl = cpy.Template(tmpl)(self = clsSelf, body = tmpl.body)
@@ -864,18 +867,19 @@ object desugar {
    *  @param parentType   The type of `parent`
    */
   def refinedTypeToClass(parent: tpd.Tree, refinements: List[Tree])(implicit ctx: Context): TypeDef = {
-    def stripToCore(tp: Type): Type = tp match {
-      case tp: RefinedType if tp.argInfos.nonEmpty => tp // parameterized class type
-      case tp: TypeRef if tp.symbol.isClass => tp        // monomorphic class type
+    def stripToCore(tp: Type): List[Type] = tp match {
+      case tp: RefinedType if tp.argInfos.nonEmpty => tp :: Nil // parameterized class type
+      case tp: TypeRef if tp.symbol.isClass => tp :: Nil     // monomorphic class type
       case tp: TypeProxy => stripToCore(tp.underlying)
-      case _ => defn.AnyType
+      case AndType(tp1, tp2) => stripToCore(tp1) ::: stripToCore(tp2)
+      case _ => defn.AnyType :: Nil
     }
-    val parentCore = stripToCore(parent.tpe)
+    val parentCores = stripToCore(parent.tpe)
     val untpdParent = TypedSplice(parent)
-    val (classParent, self) =
-      if (parent.tpe eq parentCore) (untpdParent, EmptyValDef)
-      else (TypeTree(parentCore), ValDef(nme.WILDCARD, untpdParent, EmptyTree))
-    val impl = Template(emptyConstructor, classParent :: Nil, self, refinements)
+    val (classParents, self) =
+      if (parentCores.length == 1 && (parent.tpe eq parentCores.head)) (untpdParent :: Nil, EmptyValDef)
+      else (parentCores map TypeTree, ValDef(nme.WILDCARD, untpdParent, EmptyTree))
+    val impl = Template(emptyConstructor, classParents, self, refinements)
     TypeDef(tpnme.REFINE_CLASS, impl).withFlags(Trait)
   }
 

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

@@ -48,6 +48,12 @@ abstract class Positioned extends DotClass with Product {
    */
   def addPos(pos: Position): this.type = withPos(pos union this.pos)
 
+  /** Set position of this tree only, without performing
+   *  any checks of consistency with - or updates of - other positions.
+   *  Called from Unpickler when entering positions.
+   */
+  private[dotc] def setPosUnchecked(pos: Position) = curPos = pos
+
   /** If any children of this node do not have positions, set them to the given position,
    *  and transitively visit their children.
    */

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

@@ -24,20 +24,14 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
     case _ => false
   }
 
-  /** Is tree legal as a member definition of an interface?
+  /** Does tree contain an initialization part when seen as a member of a class or trait?
    */
-  def isPureInterfaceMember(tree: Tree): Boolean = unsplice(tree) match {
+  def isNoInitMember(tree: Tree): Boolean = unsplice(tree) match {
     case EmptyTree | Import(_, _) | TypeDef(_, _) => true
-    case DefDef(_, _, _, _, rhs) => rhs.isEmpty
-    case ValDef(_, _, rhs) => rhs.isEmpty
+    case tree: ValDef => tree.unforcedRhs == EmptyTree
     case _ => false
   }
 
-  /** Is tree legal as a member definition of a no-init trait?
-   */
-  def isNoInitMember(tree: Tree): Boolean =
-    isPureInterfaceMember(tree) || unsplice(tree).isInstanceOf[DefDef]
-
   def isOpAssign(tree: Tree) = unsplice(tree) match {
     case Apply(fn, _ :: Nil) =>
       unsplice(fn) match {
@@ -90,8 +84,8 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
   }
 
   /** If tree is a closure, it's body, otherwise tree itself */
-  def closureBody(tree: tpd.Tree): tpd.Tree = tree match {
-    case Block(DefDef(nme.ANON_FUN, _, _, _, rhs) :: Nil, Closure(_, _, _)) => rhs
+  def closureBody(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = tree match {
+    case Block((meth @ DefDef(nme.ANON_FUN, _, _, _, _)) :: Nil, Closure(_, _, _)) => meth.rhs
     case _ => tree
   }
 
@@ -244,12 +238,14 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
   /** Is this case guarded? */
   def isGuardedCase(cdef: CaseDef) = cdef.guard ne EmptyTree
 
-  /** True iff definition if a val or def with no right-hand-side, or it
+  /** True iff definition is a val or def with no right-hand-side, or it
    *  is an abstract typoe declaration
    */
   def lacksDefinition(mdef: MemberDef)(implicit ctx: Context) = mdef match {
-    case mdef: ValOrDefDef => mdef.rhs.isEmpty && !mdef.name.isConstructorName && !mdef.mods.is(ParamAccessor)
-    case mdef: TypeDef => mdef.rhs.isEmpty || mdef.rhs.isInstanceOf[TypeBoundsTree]
+    case mdef: ValOrDefDef => 
+      mdef.unforcedRhs == EmptyTree && !mdef.name.isConstructorName && !mdef.mods.is(ParamAccessor)
+    case mdef: TypeDef => 
+      mdef.rhs.isEmpty || mdef.rhs.isInstanceOf[TypeBoundsTree]
     case _ => false
   }
 
@@ -287,8 +283,8 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
        | Import(_, _)
        | DefDef(_, _, _, _, _) =>
       Pure
-    case vdef @ ValDef(_, _, rhs) =>
-      if (vdef.mods is Mutable) Impure else exprPurity(rhs)
+    case vdef @ ValDef(_, _, _) =>
+      if (vdef.mods is Mutable) Impure else exprPurity(vdef.rhs)
     case _ =>
       Impure
   }
@@ -410,7 +406,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
   /** The variables defined by a pattern, in reverse order of their appearance. */
   def patVars(tree: Tree)(implicit ctx: Context): List[Symbol] = {
     val acc = new TreeAccumulator[List[Symbol]] {
-      def apply(syms: List[Symbol], tree: Tree) = tree match {
+      def apply(syms: List[Symbol], tree: Tree)(implicit ctx: Context) = tree match {
         case Bind(_, body) => apply(tree.symbol :: syms, body)
         case _ => foldOver(syms, tree)
       }
@@ -452,7 +448,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
   def defPath(sym: Symbol, root: Tree)(implicit ctx: Context): List[Tree] = ctx.debugTraceIndented(s"defpath($sym with position ${sym.pos}, ${root.show})") {
     require(sym.pos.exists)
     object accum extends TreeAccumulator[List[Tree]] {
-      def apply(x: List[Tree], tree: Tree): List[Tree] = {
+      def apply(x: List[Tree], tree: Tree)(implicit ctx: Context): List[Tree] = {
         if (tree.envelope.contains(sym.pos))
           if (definedSym(tree) == sym) tree :: x
           else {
@@ -478,7 +474,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
           if (stats exists (definedSym(_) == sym)) stats else Nil
         encl match {
           case Block(stats, _) => verify(stats)
-          case Template(_, _, _, stats) => verify(stats)
+          case encl: Template => verify(encl.body)
           case PackageDef(_, stats) => verify(stats)
           case _ => Nil
         }

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

@@ -78,22 +78,22 @@ final class TreeTypeMap(
     }
 
   override def transform(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = treeMap(tree) match {
-    case impl @ Template(constr, parents, self, body) =>
+    case impl @ Template(constr, parents, self, _) =>
       val tmap = withMappedSyms(localSyms(impl :: self :: Nil))
       cpy.Template(impl)(
           constr = tmap.transformSub(constr),
           parents = parents mapconserve transform,
           self = tmap.transformSub(self),
-          body = body mapconserve tmap.transform
+          body = impl.body mapconserve tmap.transform
         ).withType(tmap.mapType(impl.tpe))
     case tree1 =>
       tree1.withType(mapType(tree1.tpe)) match {
         case id: Ident if tpd.needsSelect(id.tpe) =>
           ref(id.tpe.asInstanceOf[TermRef]).withPos(id.pos)
-        case ddef @ DefDef(name, tparams, vparamss, tpt, rhs) =>
+        case ddef @ DefDef(name, tparams, vparamss, tpt, _) =>
           val (tmap1, tparams1) = transformDefs(ddef.tparams)
           val (tmap2, vparamss1) = tmap1.transformVParamss(vparamss)
-          cpy.DefDef(ddef)(name, tparams1, vparamss1, tmap2.transform(tpt), tmap2.transform(rhs))
+          cpy.DefDef(ddef)(name, tparams1, vparamss1, tmap2.transform(tpt), tmap2.transform(ddef.rhs))
         case blk @ Block(stats, expr) =>
           val (tmap1, stats1) = transformDefs(stats)
           val expr1 = tmap1.transform(expr)