Implement pickling and unpickling of computed types

Author: odersky

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

@@ -291,6 +291,12 @@ trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped]
     case _ => tree
   }
 
+  def isBounds(tree: Tree)(implicit ctx: Context) = tree match {
+    case tree: TypeBoundsTree => true
+    case TypedSplice(tree1) => tree1.tpe.isInstanceOf[TypeBounds]
+    case _ => false
+  }
+
   /** True iff definition is a val or def with no right-hand-side, or it
    *  is an abstract typoe declaration
    */

compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala

@@ -58,7 +58,11 @@ Standard-Section: "ASTs" TopLevelStat*
                   VALDEF         Length NameRef type_Term rhs_Term? Modifier*
                   DEFDEF         Length NameRef TypeParam* Params* returnType_Term rhs_Term?
                                         Modifier*
-                  TYPEDEF        Length NameRef (type_Term | Template) Modifier*
+                  TYPEDEF        Length NameRef
+                                        ( type_Term
+                                        | Template
+                                        | TypeParam* Params* returnType_Term rhs_Term
+                                        ) Modifier*
                   OBJECTDEF      Length NameRef Template Modifier*
                   IMPORT         Length qual_Term Selector*
   Selector      = IMPORTED              name_NameRef
@@ -510,7 +514,8 @@ object TastyFormat {
        | ANDtpt
        | ORtpt
        | BYNAMEtpt
-       | BIND => true
+       | BIND
+       | APPLY => true
     case _ => false
   }
 

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -469,7 +469,8 @@ class TreePickler(pickler: TastyPickler) {
               withLength { pickleParams(vparams) }
             }
           }
-          pickleDef(DEFDEF, tree.symbol, tree.tpt, tree.rhs, pickleAllParams)
+          val tag = if (tree.symbol.isTerm) DEFDEF else TYPEDEF
+          pickleDef(tag, tree.symbol, tree.tpt, tree.rhs, pickleAllParams)
         case tree: TypeDef =>
           pickleDef(TYPEDEF, tree.symbol, tree.rhs)
         case tree: Template =>

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -438,6 +438,7 @@ class TreeUnpickler(reader: TastyReader,
       var flags = givenFlags
       if (lacksDefinition && tag != PARAM) flags |= Deferred
       if (tag == DEFDEF) flags |= Method
+      if (tag == TYPEDEF && givenFlags.is(Transparent)) flags |= TypeMethod
       if (givenFlags is Module)
         flags = flags | (if (tag == VALDEF) ModuleValCreationFlags else ModuleClassCreationFlags)
       if (ctx.owner.isClass) {
@@ -754,28 +755,33 @@ class TreeUnpickler(reader: TastyReader,
         ta.assignType(untpd.ValDef(sym.name.asTermName, tpt, readRhs(localCtx)), sym)
 
       def DefDef(tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree) =
-         ta.assignType(
-            untpd.DefDef(sym.name.asTermName, tparams, vparamss, tpt, readRhs(localCtx)),
-            sym)
+        ta.assignType(
+          untpd.DefDef(sym.name, tparams, vparamss, tpt, readRhs(localCtx)),
+          sym)
 
       def TypeDef(rhs: Tree) =
         ta.assignType(untpd.TypeDef(sym.name.asTypeName, rhs), sym)
 
       def ta =  ctx.typeAssigner
 
       val name = readName()
+
+      def readDefDef() = {
+        val tparams = readParams[TypeDef](TYPEPARAM)(localCtx)
+        val vparamss = readParamss(localCtx)
+        val tpt = readTpt()(localCtx)
+        val typeParams = tparams.map(_.symbol.asType)
+        val valueParamss = ctx.normalizeIfConstructor(
+            vparamss.nestedMap(_.symbol.asTerm), name == nme.CONSTRUCTOR)
+        val resType = ctx.effectiveResultType(sym, typeParams, tpt.tpe)
+        sym.info = ctx.lambdaType(typeParams, valueParamss, resType, sym)
+        DefDef(tparams, vparamss, tpt)
+      }
+
       pickling.println(s"reading def of $name at $start")
       val tree: MemberDef = tag match {
         case DEFDEF =>
-          val tparams = readParams[TypeDef](TYPEPARAM)(localCtx)
-          val vparamss = readParamss(localCtx)
-          val tpt = readTpt()(localCtx)
-          val typeParams = tparams.map(_.symbol.asType)
-          val valueParamss = ctx.normalizeIfConstructor(
-              vparamss.nestedMap(_.symbol.asTerm), name == nme.CONSTRUCTOR)
-          val resType = ctx.effectiveResultType(sym, typeParams, tpt.tpe)
-          sym.info = ctx.termLambda(typeParams, valueParamss, resType, sym)
-          DefDef(tparams, vparamss, tpt)
+          readDefDef()
         case VALDEF =>
           val tpt = readTpt()(localCtx)
           sym.info = tpt.tpe
@@ -795,7 +801,10 @@ class TreeUnpickler(reader: TastyReader,
               else sym.registerCompanionMethod(nme.COMPANION_MODULE_METHOD, companion)
             }
             TypeDef(readTemplate(localCtx))
-          } else {
+          }
+          else if (sym.is(Transparent))
+            readDefDef()
+          else {
             sym.info = TypeBounds.empty // needed to avoid cyclic references when unpicklin rhs, see i3816.scala
             sym.setFlag(Provisional)
             val rhs = readTpt()(localCtx)
@@ -1337,8 +1346,13 @@ class TreeUnpickler(reader: TastyReader,
           case ALTERNATIVE =>
             untpd.Alternative(until(end)(readUntyped()))
           case DEFDEF =>
-            untpd.DefDef(readName(), readParams[TypeDef](TYPEPARAM), readParamss(), readUntyped(), readRhs())
-              .withMods(readMods())
+            var name = readName()
+            val tparams = readParams[TypeDef](TYPEPARAM)
+            val vparamss = readParamss()
+            val tpt = readUntyped()
+            untpd.DefDef(
+              if (untpd.isBounds(tpt)) name.toTypeName else name,
+              tparams, vparamss, tpt, readRhs()).withMods(readMods())
           case VALDEF | PARAM =>
             untpd.ValDef(readName(), readUntyped(), readRhs())
               .withMods(readMods())

compiler/src/dotty/tools/dotc/typer/Namer.scala

@@ -131,7 +131,7 @@ trait NamerContextOps { this: Context =>
       termParamss
 
   /** The method type corresponding to given parameters and result type */
-  def termLambda(typeParams: List[TypeSymbol], valueParamss: List[List[TermSymbol]], resultType: Type, sym: Symbol)(implicit ctx: Context): Type = {
+  def lambdaType(typeParams: List[TypeSymbol], valueParamss: List[List[TermSymbol]], resultType: Type, sym: Symbol)(implicit ctx: Context): Type = {
     val monotpe =
       (valueParamss :\ resultType) { (params, resultType) =>
         if (sym.isTerm) {
@@ -1247,7 +1247,7 @@ class Namer { typer: Typer =>
     def wrapMethType(restpe: Type): Type = {
       if (sym.isType) assert(restpe.isInstanceOf[TypeBounds], restpe)
       instantiateDependent(restpe, typeParams, termParamss)
-      ctx.termLambda(typeParams, termParamss, restpe, sym)
+      ctx.lambdaType(typeParams, termParamss, restpe, sym)
     }
     if (isConstructor) {
       // set result type tree to unit, but take the current class as result type of the symbol