Tweaks to Tasty pickling and unpickling

 - some fixes to format docs
 - some refactorings for better legibility

Author: odersky

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

@@ -65,11 +65,11 @@ Standard-Section: "ASTs" TopLevelStat*
 
                                  // Imports are for scala.meta, they are not used in the backend
 
-  TypeParam     = TYPEPARAM      Length NameRef Type Modifier*
+  TypeParam     = TYPEPARAM      Length NameRef type_Term Modifier*
   Params        = PARAMS         Length Param*
-  Param         = PARAM          Length NameRef Type rhs_Term? Modifier*  // rhs_Term is present in the case of an aliased class parameter
+  Param         = PARAM          Length NameRef type_Term rhs_Term? Modifier*  // rhs_Term is present in the case of an aliased class parameter
   Template      = TEMPLATE       Length TypeParam* Param* parent_Term* Self? Stat* // Stat* always starts with the primary constructor.
-  Self          = SELFDEF               selfName_NameRef selfType_Type
+  Self          = SELFDEF               selfName_NameRef selfType_Term
 
   Term          = Path
                   IDENT                 NameRef Type     // used when term ident’s type is not a TermRef

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

@@ -504,16 +504,7 @@ class TreePickler(pickler: TastyPickler) {
           }
         case Import(expr, selectors) =>
           writeByte(IMPORT)
-          withLength {
-            pickleTree(expr)
-            selectors foreach {
-              case Thicket((from @ Ident(_)) :: (to @ Ident(_)) :: Nil) =>
-                pickleSelector(IMPORTED, from)
-                pickleSelector(RENAMED, to)
-              case id @ Ident(_) =>
-                pickleSelector(IMPORTED, id)
-            }
-          }
+          withLength { pickleTree(expr); pickleSelectors(selectors) }
         case PackageDef(pid, stats) =>
           writeByte(PACKAGE)
           withLength { pickleType(pid.tpe); pickleStats(stats) }
@@ -569,6 +560,15 @@ class TreePickler(pickler: TastyPickler) {
       }
   }
 
+  def pickleSelectors(selectors: List[untpd.Tree])(implicit ctx: Context): Unit =
+    selectors foreach {
+      case Thicket((from @ Ident(_)) :: (to @ Ident(_)) :: Nil) =>
+        pickleSelector(IMPORTED, from)
+        pickleSelector(RENAMED, to)
+      case id @ Ident(_) =>
+        pickleSelector(IMPORTED, id)
+    }
+
   def pickleSelector(tag: Int, id: untpd.Ident)(implicit ctx: Context): Unit = {
     registerTreeAddr(id)
     writeByte(tag)
@@ -600,15 +600,15 @@ class TreePickler(pickler: TastyPickler) {
     if (sym.isTerm) {
       if (flags is Implicit) writeByte(IMPLICIT)
       if (flags is Erased) writeByte(ERASED)
-      if ((flags is Lazy) && !(sym is Module)) writeByte(LAZY)
+      if (flags.is(Lazy, butNot = Module)) writeByte(LAZY)
       if (flags is AbsOverride) { writeByte(ABSTRACT); writeByte(OVERRIDE) }
       if (flags is Mutable) writeByte(MUTABLE)
       if (flags is Accessor) writeByte(FIELDaccessor)
       if (flags is CaseAccessor) writeByte(CASEaccessor)
       if (flags is DefaultParameterized) writeByte(DEFAULTparameterized)
       if (flags is Stable) writeByte(STABLE)
       if ((flags is ParamAccessor) && sym.isSetter) writeByte(PARAMsetter)
-      if ((flags is Label)) writeByte(LABEL)
+      if (flags is Label) writeByte(LABEL)
     } else {
       if (flags is Sealed) writeByte(SEALED)
       if (flags is Abstract) writeByte(ABSTRACT)

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

@@ -228,6 +228,39 @@ class TreeUnpickler(reader: TastyReader,
         createSymbol()
     }
 
+    def readConstant(tag: Int)(implicit ctx: Context): Constant = (tag: @switch) match {
+      case UNITconst =>
+        Constant(())
+      case TRUEconst =>
+        Constant(true)
+      case FALSEconst =>
+        Constant(false)
+      case BYTEconst =>
+        Constant(readInt().toByte)
+      case SHORTconst =>
+        Constant(readInt().toShort)
+      case CHARconst =>
+        Constant(readNat().toChar)
+      case INTconst =>
+        Constant(readInt())
+      case LONGconst =>
+        Constant(readLongInt())
+      case FLOATconst =>
+        Constant(java.lang.Float.intBitsToFloat(readInt()))
+      case DOUBLEconst =>
+        Constant(java.lang.Double.longBitsToDouble(readLongInt()))
+      case STRINGconst =>
+        Constant(readName().toString)
+      case NULLconst =>
+        Constant(null)
+      case CLASSconst =>
+        Constant(readType())
+      case ENUMconst =>
+        Constant(readTermRef().termSymbol)
+      case SYMBOLconst =>
+        Constant(scala.Symbol(readName().toString))
+    }
+
     /** Read a type */
     def readType()(implicit ctx: Context): Type = {
       val start = currentAddr
@@ -313,10 +346,6 @@ class TreeUnpickler(reader: TastyReader,
               readTypeRef() match {
                 case binder: LambdaType => binder.paramRefs(readNat())
               }
-            case CLASSconst =>
-              ConstantType(Constant(readType()))
-            case ENUMconst =>
-              ConstantType(Constant(readTermRef().termSymbol))
             case HOLE =>
               readHole(end, isType = true).tpe
           }
@@ -356,38 +385,10 @@ class TreeUnpickler(reader: TastyReader,
         case SHAREDtype =>
           val ref = readAddr()
           typeAtAddr.getOrElseUpdate(ref, forkAt(ref).readType())
-        case UNITconst =>
-          ConstantType(Constant(()))
-        case TRUEconst =>
-          ConstantType(Constant(true))
-        case FALSEconst =>
-          ConstantType(Constant(false))
-        case BYTEconst =>
-          ConstantType(Constant(readInt().toByte))
-        case SHORTconst =>
-          ConstantType(Constant(readInt().toShort))
-        case CHARconst =>
-          ConstantType(Constant(readNat().toChar))
-        case INTconst =>
-          ConstantType(Constant(readInt()))
-        case LONGconst =>
-          ConstantType(Constant(readLongInt()))
-        case FLOATconst =>
-          ConstantType(Constant(java.lang.Float.intBitsToFloat(readInt())))
-        case DOUBLEconst =>
-          ConstantType(Constant(java.lang.Double.longBitsToDouble(readLongInt())))
-        case STRINGconst =>
-          ConstantType(Constant(readName().toString))
-        case NULLconst =>
-          ConstantType(Constant(null))
-        case CLASSconst =>
-          ConstantType(Constant(readType()))
-        case ENUMconst =>
-          ConstantType(Constant(readTermRef().termSymbol))
-        case SYMBOLconst =>
-          ConstantType(Constant(scala.Symbol(readName().toString)))
         case BYNAMEtype =>
           ExprType(readType())
+        case _ =>
+          ConstantType(readConstant(tag))
       }
 
       if (tag < firstLengthTreeTag) readSimpleType() else readLengthType()
@@ -420,7 +421,7 @@ class TreeUnpickler(reader: TastyReader,
 
 // ------ Reading definitions -----------------------------------------------------
 
-    private def noRhs(end: Addr): Boolean =
+    private def nothingButMods(end: Addr): Boolean =
       currentAddr == end || isModifierTag(nextByte)
 
     private def localContext(owner: Symbol)(implicit ctx: Context) =
@@ -510,7 +511,7 @@ class TreeUnpickler(reader: TastyReader,
       val templateStart = currentAddr
       skipTree() // tpt
       val rhsStart = currentAddr
-      val rhsIsEmpty = noRhs(end)
+      val rhsIsEmpty = nothingButMods(end)
       if (!rhsIsEmpty) skipTree()
       val (givenFlags, annots, privateWithin) = readModifiers(end)
       pickling.println(i"creating symbol $name at $start with flags $givenFlags")
@@ -562,7 +563,7 @@ class TreeUnpickler(reader: TastyReader,
      */
     def readModifiers(end: Addr)(implicit ctx: Context): (FlagSet, List[Annotation], Symbol) = {
       var flags: FlagSet = EmptyFlags
-      var annots = new mutable.ListBuffer[Annotation]
+      var annots: List[Annotation] = Nil
       var privateWithin: Symbol = NoSymbol
       while (currentAddr.index != end.index) {
         def addFlag(flag: FlagSet) = {
@@ -613,18 +614,23 @@ class TreeUnpickler(reader: TastyReader,
             addFlag(Protected)
             privateWithin = readType().typeSymbol
           case ANNOTATION =>
-            readByte()
-            val end = readEnd()
-            val tp = readType()
-            val lazyAnnotTree = readLater(end, rdr => ctx => rdr.readTerm()(ctx))
-            annots += Annotation.deferredSymAndTree(
-              implicit ctx => tp.typeSymbol,
-              implicit ctx => lazyAnnotTree.complete)
+            annots = readAnnot(ctx) :: annots
           case tag =>
             assert(false, s"illegal modifier tag $tag at $currentAddr, end = $end")
         }
       }
-      (flags, annots.toList, privateWithin)
+      (flags, annots.reverse, privateWithin)
+    }
+
+    private val readAnnot: Context => Annotation = {
+      implicit ctx =>
+        readByte()
+        val end = readEnd()
+        val tp = readType()
+        val lazyAnnotTree = readLater(end, rdr => ctx => rdr.readTerm()(ctx))
+        Annotation.deferredSymAndTree(
+          implicit ctx => tp.typeSymbol,
+          implicit ctx => lazyAnnotTree.complete)
     }
 
     /** Create symbols for the definitions in the statement sequence between
@@ -721,7 +727,7 @@ class TreeUnpickler(reader: TastyReader,
       val localCtx = localContext(sym)
 
       def readRhs(implicit ctx: Context) =
-        if (noRhs(end)) EmptyTree
+        if (nothingButMods(end)) EmptyTree
         else readLater(end, rdr => ctx => rdr.readTerm()(ctx.retractMode(Mode.InSuperCall)))
 
       def ValDef(tpt: Tree) =
@@ -786,7 +792,7 @@ class TreeUnpickler(reader: TastyReader,
           }
         case PARAM =>
           val tpt = readTpt()(localCtx)
-          if (noRhs(end)) {
+          if (nothingButMods(end)) {
             sym.info = tpt.tpe
             ValDef(tpt)
           }