Drop EMPTYTREE tag in Tasty

Needs a revised Inlined pickling format

Author: odersky

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

@@ -949,11 +949,6 @@ object Trees {
       case ys => Thicket(ys)
     }
 
-    /** Extractor for the synthetic scrutinee tree of an implicit match */
-    object ImplicitScrutinee {
-      def apply() = Ident(nme.IMPLICITkw)
-      def unapply(id: Ident): Boolean = id.name == nme.IMPLICITkw && !id.isInstanceOf[BackquotedIdent]
-    }
     // ----- Helper classes for copying, transforming, accumulating -----------------
 
     val cpy: TreeCopier

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

@@ -55,12 +55,13 @@ Standard-Section: "ASTs" TopLevelStat*
                   Stat
 
   Stat          = Term
-                  VALDEF         Length NameRef type_Term rhs_Term? Modifier*
-                  DEFDEF         Length NameRef TypeParam* Params* returnType_Term rhs_Term?
-                                        Modifier*
+                  ValOrDefDef
                   TYPEDEF        Length NameRef (type_Term | Template) Modifier*
                   OBJECTDEF      Length NameRef Template Modifier*
                   IMPORT         Length qual_Term Selector*
+  ValOrDefDef   = VALDEF         Length NameRef type_Term rhs_Term? Modifier*
+                  DEFDEF         Length NameRef TypeParam* Params* returnType_Term rhs_Term?
+                                        Modifier*
   Selector      = IMPORTED              name_NameRef
                   RENAMED               to_NameRef
 
@@ -85,7 +86,7 @@ Standard-Section: "ASTs" TopLevelStat*
                   TYPED          Length expr_Term ascriptionType_Tern
                   ASSIGN         Length lhs_Term rhs_Term
                   BLOCK          Length expr_Term Stat*
-                  INLINED        Length call_Term expr_Term Stat*
+                  INLINED        Length expr_Term call_Term? ValOrDefDef*
                   LAMBDA         Length meth_Term target_Type?
                   IF             Length cond_Term then_Term else_Term
                   MATCH          Length sel_Term CaseDef*
@@ -109,7 +110,6 @@ Standard-Section: "ASTs" TopLevelStat*
                   ORtpt          Length left_Term right_Term
                   MATCHtpt       Length bound_Term? sel_Term CaseDef*
                   BYNAMEtpt             underlying_Term
-                  EMPTYTREE
                   SHAREDterm            term_ASTRef
                   HOLE           Length idx_Nat arg_Tree*
 
@@ -310,7 +310,6 @@ object TastyFormat {
   final val MACRO = 34
   final val ERASED = 35
   final val PARAMsetter = 36
-  final val EMPTYTREE = 37
 
   // Cat. 2:    tag Nat
 
@@ -441,7 +440,7 @@ object TastyFormat {
 
   /** Useful for debugging */
   def isLegalTag(tag: Int) =
-    firstSimpleTreeTag <= tag && tag <= EMPTYTREE ||
+    firstSimpleTreeTag <= tag && tag <= PARAMsetter ||
     firstNatTreeTag <= tag && tag <= SYMBOLconst ||
     firstASTTreeTag <= tag && tag <= SINGLETONtpt ||
     firstNatASTTreeTag <= tag && tag <= NAMEDARG ||
@@ -539,7 +538,6 @@ object TastyFormat {
     case DEFAULTparameterized => "DEFAULTparameterized"
     case STABLE => "STABLE"
     case PARAMsetter => "PARAMsetter"
-    case EMPTYTREE => "EMPTYTREE"
 
     case SHAREDterm => "SHAREDterm"
     case SHAREDtype => "SHAREDtype"

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

@@ -448,7 +448,14 @@ class TreePickler(pickler: TastyPickler) {
         case Inlined(call, bindings, expansion) =>
           writeByte(INLINED)
           bindings.foreach(preRegister)
-          withLength { pickleTree(call); pickleTree(expansion); bindings.foreach(pickleTree) }
+          withLength {
+            pickleTree(expansion)
+            if (!call.isEmpty) pickleTree(call)
+            bindings.foreach { b =>
+              assert(b.isInstanceOf[DefDef] || b.isInstanceOf[ValDef])
+              pickleTree(b)
+            }
+          }
         case Bind(name, body) =>
           registerDef(tree.symbol)
           writeByte(BIND)
@@ -563,8 +570,6 @@ class TreePickler(pickler: TastyPickler) {
             pickleTree(lo);
             if (hi ne lo) pickleTree(hi)
           }
-        case EmptyTree =>
-          writeByte(EMPTYTREE)
         case Hole(idx, args) =>
           writeByte(HOLE)
           withLength {

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

@@ -1045,23 +1045,12 @@ class TreeUnpickler(reader: TastyReader,
           ByNameTypeTree(readTpt())
         case NAMEDARG =>
           NamedArg(readName(), readTerm())
-        case EMPTYTREE =>
-          EmptyTree
         case _ =>
           readPathTerm()
       }
 
       def readLengthTerm(): Tree = {
         val end = readEnd()
-
-        def readBlock(mkTree: (List[Tree], Tree) => Tree): Tree = {
-          val exprReader = fork
-          skipTree()
-          val stats = readStats(ctx.owner, end)
-          val expr = exprReader.readTerm()
-          mkTree(stats, expr)
-        }
-
         val result =
           (tag: @switch) match {
             case SUPER =>
@@ -1080,10 +1069,22 @@ class TreeUnpickler(reader: TastyReader,
             case ASSIGN =>
               Assign(readTerm(), readTerm())
             case BLOCK =>
-              readBlock(Block)
+              val exprReader = fork
+              skipTree()
+              val stats = readStats(ctx.owner, end)
+              val expr = exprReader.readTerm()
+              Block(stats, expr)
             case INLINED =>
-              val call = readTerm()
-              readBlock((defs, expr) => Inlined(call, defs.asInstanceOf[List[MemberDef]], expr))
+              val exprReader = fork
+              skipTree()
+              def maybeCall = nextUnsharedTag match {
+                case VALDEF | DEFDEF => EmptyTree
+                case _ => readTerm()
+              }
+              val call = ifBefore(end)(maybeCall, EmptyTree)
+              val bindings = readStats(ctx.owner, end).asInstanceOf[List[ValOrDefDef]]
+              val expansion = exprReader.readTerm() // need bindings in scope, so needs to be read before
+              Inlined(call, bindings, expansion)
             case IF =>
               If(readTerm(), readTerm(), readTerm())
             case LAMBDA =>
@@ -1298,8 +1299,10 @@ class TreeUnpickler(reader: TastyReader,
       def search(cs: List[OwnerTree], current: Symbol): Symbol =
         try cs match {
         case ot :: cs1 =>
-          if (ot.addr.index == addr.index)
+          if (ot.addr.index == addr.index) {
+            assert(current.exists, i"no symbol at $addr")
             current
+          }
           else if (ot.addr.index < addr.index && addr.index < ot.end.index)
             search(ot.children, reader.symbolAt(ot.addr))
           else