Add untyped types to Tasty

odersky · odersky · commit c8c0aabadf19 · 2018-06-15T09:24:56.000-07:00
Allow UNTYPEDSPLICE roots with TYPEDSPLICE subtrees. Trees between them are untyped.
diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -642,7 +642,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
   override def skipTransform(tree: Tree)(implicit ctx: Context) = tree.tpe.isError
 
-  implicit class TreeOps[ThisTree <: tpd.Tree](val tree: ThisTree) extends AnyVal {
+  implicit class TreeOps[ThisTree <: tpd.Tree](private val tree: ThisTree) extends AnyVal {
 
     def isValue(implicit ctx: Context): Boolean =
       tree.isTerm && tree.tpe.widen.isValueType
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala b/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala
@@ -59,6 +59,7 @@ Standard-Section: "ASTs" TopLevelStat*
                   DEFDEF         Length NameRef TypeParam* Params* returnType_Term rhs_Term?
                                         Modifier*
                   TYPEDEF        Length NameRef (type_Term | Template) Modifier*
+                  OBJECTDEF      Length NameRef Template Mods
                   IMPORT         Length qual_Term Selector*
   Selector      = IMPORTED              name_NameRef
                   RENAMED               to_NameRef
@@ -109,6 +110,7 @@ Standard-Section: "ASTs" TopLevelStat*
                   EMPTYTREE
                   SHAREDterm            term_ASTRef
                   HOLE           Length idx_Nat arg_Tree*
+                  UNTYPEDSPLICE  Length splice_TermUntyped splice_Type
 
   CaseDef       = CASEDEF        Length pat_Term rhs_Tree guard_Tree?
   ImplicitArg   = IMPLICITARG           arg_Term
@@ -203,6 +205,13 @@ Standard-Section: "ASTs" TopLevelStat*
 
   Annotation    = ANNOTATION     Length tycon_Type fullAnnotation_Term
 
+// --------------- untyped additions ------------------------------------------
+
+  TermUntyped   = Term
+                  FUNCTION    Length body_Term arg_Term*
+                  INFIXOP     Length op_NameRef left_Term right_Term
+                  TYPEDSPLICE Length splice_Term
+
 Note: Tree tags are grouped into 5 categories that determine what follows, and thus allow to compute the size of the tagged tree in a generic way.
 
   Category 1 (tags 1-49)   :  tag
@@ -402,6 +411,7 @@ object TastyFormat {
   final val ANNOTATION = 172
   final val TERMREFin = 173
   final val TYPEREFin = 174
+  final val OBJECTDEF = 175
 
   // In binary: 101100EI
   // I = implicit method type
@@ -411,6 +421,13 @@ object TastyFormat {
   final val ERASEDMETHODtype = 178
   final val ERASEDIMPLICITMETHODtype = 179
 
+  final val UNTYPEDSPLICE = 199
+
+  // Tags for untyped trees only:
+  final val TYPEDSPLICE = 200
+  final val FUNCTION = 201
+  final val INFIXOP = 202
+
   def methodType(isImplicit: Boolean = false, isErased: Boolean = false) = {
     val implicitOffset = if (isImplicit) 1 else 0
     val erasedOffset = if (isErased) 2 else 0
@@ -554,6 +571,7 @@ object TastyFormat {
     case VALDEF => "VALDEF"
     case DEFDEF => "DEFDEF"
     case TYPEDEF => "TYPEDEF"
+    case OBJECTDEF => "OBJECTDEF"
     case IMPORT => "IMPORT"
     case TYPEPARAM => "TYPEPARAM"
     case PARAMS => "PARAMS"
@@ -621,13 +639,18 @@ object TastyFormat {
     case PRIVATEqualified => "PRIVATEqualified"
     case PROTECTEDqualified => "PROTECTEDqualified"
     case HOLE => "HOLE"
+
+    case UNTYPEDSPLICE => "UNTYPEDSPLICE"
+    case TYPEDSPLICE => "TYPEDSPLICE"
+    case FUNCTION => "FUNCTION"
+    case INFIXOP => "INFIXOP"
   }
 
   /** @return If non-negative, the number of leading references (represented as nats) of a length/trees entry.
    *          If negative, minus the number of leading non-reference trees.
    */
   def numRefs(tag: Int) = tag match {
-    case VALDEF | DEFDEF | TYPEDEF | TYPEPARAM | PARAM | NAMEDARG | RETURN | BIND |
+    case VALDEF | DEFDEF | TYPEDEF | OBJECTDEF | TYPEPARAM | PARAM | NAMEDARG | RETURN | BIND |
          SELFDEF | REFINEDtype | TERMREFin | TYPEREFin | HOLE => 1
     case RENAMED | PARAMtype => 2
     case POLYtype | METHODtype | TYPELAMBDAtype => -1
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -4,7 +4,7 @@ package core
 package tasty
 
 import ast.Trees._
-import ast.{untpd, tpd}
+import ast.{untpd, tpd, desugar}
 import TastyFormat._
 import Contexts._, Symbols._, Types._, Names._, Constants._, Decorators._, Annotations._, StdNames.tpnme, NameOps._
 import collection.mutable
@@ -546,6 +546,10 @@ class TreePickler(pickler: TastyPickler) {
             pickleTree(lo);
             if (hi ne lo) pickleTree(hi)
           }
+        case tpd.UntypedSplice(splice) =>
+          //println(i"UNTYPED: $splice")
+          writeByte(UNTYPEDSPLICE)
+          withLength { pickleUntyped(splice); pickleType(tree.tpe) }
         case Hole(idx, args) =>
           writeByte(HOLE)
           withLength {
@@ -644,6 +648,211 @@ class TreePickler(pickler: TastyPickler) {
       withLength { pickleType(ann.symbol.typeRef); pickleTree(ann.tree) }
     }
 
+// ---- pickling untyped trees ----------------------------------
+
+  def pickleUntyped(tree: untpd.Tree)(implicit ctx: Context): Unit = {
+      try desugar(tree) match {
+        case Ident(name) =>
+          writeByte(if (name.isTypeName) TYPEREF else TERMREF)
+          pickleName(name)
+          pickleDummyType()
+        case This(qual) =>
+          writeByte(QUALTHIS)
+          pickleUntyped(qual)
+        case Select(qual, name) =>
+          writeByte(if (name.isTypeName) SELECTtpt else SELECT)
+          pickleName(name)
+          pickleUntyped(qual)
+        case Apply(fun, args) =>
+          writeByte(APPLY)
+          withLength {
+            pickleUntyped(fun)
+            args.foreach(pickleUntyped)
+          }
+        case untpd.Throw(exc) =>
+          writeByte(THROW)
+          pickleUntyped(exc)
+        case TypeApply(fun, args) =>
+          writeByte(TYPEAPPLY)
+          withLength {
+            pickleUntyped(fun)
+            args.foreach(pickleUntyped)
+          }
+        case Literal(const) =>
+          pickleConstant(const)
+        case Super(qual, mix) =>
+          writeByte(SUPER)
+          withLength {
+            pickleUntyped(qual);
+            if (!mix.isEmpty) pickleUntyped(mix)
+          }
+        case New(tpt) =>
+          writeByte(NEW)
+          pickleUntyped(tpt)
+        case Typed(expr, tpt) =>
+          writeByte(TYPED)
+          withLength { pickleUntyped(expr); pickleUntyped(tpt) }
+        case NamedArg(name, arg) =>
+          writeByte(NAMEDARG)
+          pickleName(name)
+          pickleUntyped(arg)
+        case Assign(lhs, rhs) =>
+          writeByte(ASSIGN)
+          withLength { pickleUntyped(lhs); pickleUntyped(rhs) }
+        case Block(stats, expr) =>
+          writeByte(BLOCK)
+          withLength { pickleUntyped(expr); stats.foreach(pickleUntyped) }
+        case If(cond, thenp, elsep) =>
+          writeByte(IF)
+          withLength { pickleUntyped(cond); pickleUntyped(thenp); pickleUntyped(elsep) }
+        case Match(selector, cases) =>
+          writeByte(MATCH)
+          withLength { pickleUntyped(selector); cases.foreach(pickleUntyped) }
+        case CaseDef(pat, guard, rhs) =>
+          writeByte(CASEDEF)
+          withLength { pickleUntyped(pat); pickleUntyped(rhs); pickleUntypedUnlessEmpty(guard) }
+        case Return(expr, from) =>
+          writeByte(RETURN)
+          withLength { pickleDummyRef(); pickleUntypedUnlessEmpty(expr) }
+        case Try(block, cases, finalizer) =>
+          writeByte(TRY)
+          withLength { pickleUntyped(block); cases.foreach(pickleUntyped); pickleUntypedUnlessEmpty(finalizer) }
+        case Bind(name, body) =>
+          writeByte(BIND)
+          withLength {
+            pickleName(name); pickleDummyType(); pickleUntyped(body)
+          }
+        case Alternative(alts) =>
+          writeByte(ALTERNATIVE)
+          withLength { alts.foreach(pickleUntyped) }
+        case tree: untpd.ValDef =>
+          pickleUntypedDef(VALDEF, tree, tree.tpt, tree.rhs)
+        case tree: untpd.DefDef =>
+          pickleUntypedDef(DEFDEF, tree, tree.tpt, tree.rhs, pickleAllUntypedParams(tree))
+        case tree: untpd.TypeDef =>
+          pickleUntypedDef(TYPEDEF, tree, tree.rhs)
+        case tree: untpd.ModuleDef =>
+          pickleUntypedDef(OBJECTDEF, tree, tree.impl)
+        case tree: untpd.Template =>
+          writeByte(TEMPLATE)
+          tree.parents.foreach(pickleUntyped)
+          if (!tree.self.isEmpty) {
+            writeByte(SELFDEF); pickleName(tree.self.name); pickleUntyped(tree.self.tpt)
+          }
+          pickleUntyped(tree.constr)
+          tree.body.foreach(pickleUntyped)
+        case Import(expr, selectors) =>
+          writeByte(IMPORT)
+          withLength { pickleUntyped(expr); pickleSelectors(selectors) }
+        case tree: untpd.TypeTree =>
+          pickleDummyType()
+        case SingletonTypeTree(ref) =>
+          writeByte(SINGLETONtpt)
+          pickleUntyped(ref)
+        case RefinedTypeTree(parent, refinements) =>
+          writeByte(REFINEDtpt)
+          withLength { pickleUntyped(parent); refinements.foreach(pickleUntyped) }
+        case AppliedTypeTree(tycon, args) =>
+          writeByte(APPLIEDtpt)
+          withLength { pickleUntyped(tycon); args.foreach(pickleUntyped) }
+        case AndTypeTree(tp1, tp2) =>
+          writeByte(ANDtpt)
+          withLength { pickleUntyped(tp1); pickleUntyped(tp2) }
+        case OrTypeTree(tp1, tp2) =>
+          writeByte(ORtpt)
+          withLength { pickleUntyped(tp1); pickleUntyped(tp2) }
+        case ByNameTypeTree(tp) =>
+          writeByte(BYNAMEtpt)
+          pickleUntyped(tp)
+        case Annotated(tree, annot) =>
+          writeByte(ANNOTATEDtpt)
+          withLength { pickleUntyped(tree); pickleUntyped(annot) }
+        case LambdaTypeTree(tparams, body) =>
+          writeByte(LAMBDAtpt)
+          withLength { pickleUntypedParams(tparams); pickleUntyped(body) }
+        case TypeBoundsTree(lo, hi) =>
+          writeByte(TYPEBOUNDStpt)
+          withLength {
+            pickleUntyped(lo);
+            if (hi ne lo) pickleUntyped(hi)
+          }
+        case untpd.Function(args, body) =>
+          writeByte(FUNCTION)
+          withLength { pickleUntyped(body); args.foreach(pickleUntyped) }
+        case untpd.InfixOp(l, op, r) =>
+          writeByte(INFIXOP)
+          withLength { pickleUntyped(l); pickleUntyped(op); pickleUntyped(r) }
+        case Thicket(trees) =>
+          trees.foreach(pickleUntyped)
+        case untpd.TypedSplice(splice) =>
+          writeByte(TYPEDSPLICE)
+          withLength { pickleTree(splice) }
+      }
+      catch {
+        case ex: AssertionError =>
+          println(i"error when pickling tree $tree")
+          throw ex
+      }
+  }
+
+  def pickleUntypedUnlessEmpty(tree: untpd.Tree)(implicit ctx: Context): Unit =
+    if (!tree.isEmpty) pickleUntyped(tree)
+
+  def pickleAllUntypedParams(tree: untpd.DefDef)(implicit ctx: Context): Unit = {
+    pickleUntypedParams(tree.tparams)
+    for (vparams <- tree.vparamss) {
+      writeByte(PARAMS)
+      withLength { pickleUntypedParams(vparams) }
+    }
+  }
+
+  def pickleUntypedParams(trees: List[untpd.Tree])(implicit ctx: Context): Unit =
+    trees.foreach(pickleUntypedParam)
+
+  def pickleUntypedDef(tag: Int, tree: untpd.MemberDef, tpt: untpd.Tree, rhs: untpd.Tree = untpd.EmptyTree, pickleParams: => Unit = ())(implicit ctx: Context) = {
+    import untpd.modsDeco
+    writeByte(tag)
+    withLength {
+      pickleName(tree.name)
+      pickleParams
+      pickleUntyped(tpt)
+      pickleUntypedUnlessEmpty(rhs)
+      pickleUntypedModifiers(tree.mods)
+    }
+  }
+
+  def pickleUntypedParam(tree: untpd.Tree)(implicit ctx: Context): Unit = tree match {
+    case tree: untpd.ValDef => pickleUntypedDef(PARAM, tree, tree.tpt)
+    case tree: untpd.DefDef => pickleUntypedDef(PARAM, tree, tree.tpt, tree.rhs)
+    case tree: untpd.TypeDef => pickleUntypedDef(TYPEPARAM, tree, tree.rhs)
+  }
+
+  def pickleUntypedModifiers(mods: untpd.Modifiers)(implicit ctx: Context): Unit = {
+    import Flags._
+    var flags = mods.flags
+    val privateWithin = mods.privateWithin
+    if (!privateWithin.isEmpty) {
+      writeByte(if (flags is Protected) PROTECTEDqualified else PRIVATEqualified)
+      pickleUntyped(untpd.Ident(privateWithin))
+      flags = flags &~ Protected
+    }
+    mods.annotations.foreach(pickleUntypedAnnotation)
+  }
+
+  def pickleUntypedAnnotation(annotTree: untpd.Tree)(implicit ctx: Context) = {
+    writeByte(ANNOTATION)
+    withLength { pickleDummyType(); pickleUntyped(annotTree) }
+  }
+
+  def pickleDummyRef(): Unit = writeNat(0)
+
+  def pickleDummyType(): Unit = {
+    writeByte(SHAREDtype)
+    pickleDummyRef()
+  }
+
+// ---- main entry points ---------------------------------------
+
   def pickle(trees: List[Tree])(implicit ctx: Context) = {
     trees.foreach(tree => if (!tree.isEmpty) pickleTree(tree))
     def missing = forwardSymRefs.keysIterator.map(_.showLocated).toList
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
