WIP More refinements to type pickling

Many files compile now when checkTypePositions is enabled, but
far from all. It looks complicated to track types and trees precisely in
all cases.

Author: odersky

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

@@ -114,6 +114,7 @@ object Trees {
      */
     def withType(tpe: Type)(implicit ctx: Context): ThisTree[Type] = {
       if (tpe == ErrorType) assert(ctx.reporter.errorsReported)
+      //if (this.isInstanceOf[Ident[_]]) assert(!tpe.isInstanceOf[TypeBounds])
       withTypeUnchecked(tpe)
     }
 

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

@@ -98,6 +98,8 @@ object TypePositions {
               convert(body, tpe.resultType))
         case (TypeDef(name, rhs), tpe @ TypeAlias(alias)) =>
           PointPos.add(tree, tpe.derivedTypeAlias(convert(rhs, alias)))
+        case (TypeDef(name, rhs), tpe: PolyType) if !rhs.isInstanceOf[PolyTypeTree] =>
+          PointPos.add(tree, tpe.derivedPolyType(resType = convert(rhs, tpe.resultType)))
         case (TypeDef(name, rhs), tpe) =>
           PointPos.add(tree, convert(rhs, tpe))
         case (ValDef(name, tpt, _), tpe) =>
@@ -121,14 +123,16 @@ object TypePositions {
         case (_, tpe) =>
           tpe
       }
-      tpe1 match {
+      val res = tpe1 match {
         case AnnotatedType(_, _: PosAnnot) => tpe1
         case _ => if (tree.pos.exists) AnnotatedType(tpe1, PosAnnot(tree.pos)) else tpe1
       }
+      //println(i"convert $tree: ${tree.tpe} / $tpe -> $tpe1 -> $res")
+      res
     }    
     convert(tree, tree.tpe)
   }
-     
+       
   /** Given a type produce a corresponding definition with defined name `name` 
    */
   def toDef(name: Name, tpe: Type)(implicit ctx: Context): MemberDef = {
@@ -185,12 +189,15 @@ object TypePositions {
    */
   def toTree(tpe: Type, hasPos: Boolean = false)(implicit ctx: Context): Tree = tpe match {
     case AnnotatedType(tpe1, PosAnnot(pos)) =>
-      val tree = toTree(tpe1, hasPos = true) match {
-        case t @ Select(qual, name) if name.length == pos.end - pos.start => 
-          untpd.Ident(name).withType(t.tpe)
-        case t => t
+      def addPos(tree: Tree): Tree = tree match {
+        case tree @ SingletonTypeTree(ref) => 
+          untpd.SingletonTypeTree(addPos(ref)).withType(tree.tpe)
+        case tree @ Select(qual, name) if name.length == pos.end - pos.start => 
+          untpd.Ident(name).withType(tree.tpe).withPos(pos.toSynthetic)
+        case _ => 
+          tree.withPos(pos.toSynthetic)
       }
-      tree.withPos(pos.toSynthetic)
+      addPos(toTree(tpe1, hasPos = true))
     case tpe =>
       val utree: untpd.Tree = {
         import untpd._
@@ -264,12 +271,42 @@ object TypePositions {
       utree.withType(tpe)
   }
 
-  def refPositions(tree: Tree)(implicit ctx: Context): List[(Name, Position)] = {
-    val b = new mutable.ListBuffer[(Name, Position)]
+  def adapt(rhs: Tree, tp: Type, tparams: List[untpd.TypeDef])(implicit ctx: Context): Tree = {
+    val rhs1: untpd.Tree = tp match {
+      case TypeAlias(alias) if !rhs.isInstanceOf[TypeBoundsTree] =>
+        val rhs0 = adapt(rhs, alias, tparams)
+        TypeBoundsTree(rhs0, rhs0)
+      case tp: PolyType if !rhs.isInstanceOf[PolyTypeTree] =>
+        assert(tparams.length == tp.paramNames.length, i"bad poly $tp, $tparams")
+        PolyTypeTree(tparams, rhs)
+      case _ =>
+        rhs
+    }
+    rhs1.withType(tp)
+  }
+
+  def refPositions(tree: Tree)(implicit ctx: Context): List[(String, Position)] = {
+    val b = new mutable.ListBuffer[(String, Position)]
+    def essentialSuffix(name: Name): String = 
+      name.drop(name.lastIndexOf('$') + 1).toString
     tree foreachSubTree {
-      case t: RefTree => b += ((t.name, t.pos.toSynthetic))
+      case t: RefTree => b += ((essentialSuffix(t.name), t.pos.toSynthetic))
       case _ =>
     }
     b.toList  
   }
+
+  def checkTypePositions(posType: Type, tpt: Tree)(implicit ctx: Context) = {
+    val tree = TypePositions.toTree(posType)
+    val origRefs = TypePositions.refPositions(tpt)
+    val newRefs = TypePositions.refPositions(tree)
+    assert(origRefs.map(_._2).toSet subsetOf newRefs.map(_._2).toSet,
+      i"""tpt = $tpt
+         |tptStr = ${tpt.toString}
+         |posType = $posType
+         |posTypeStr = ${posType.toString}
+         |tree = $tree
+         |origRefs = $origRefs%, %
+         |newRefs = $newRefs%, %""")
+  }
 }

src/dotty/tools/dotc/core/Types.scala

@@ -764,6 +764,7 @@ object Types {
     }
 
     def & (that: Type)(implicit ctx: Context): Type = track("&") {
+      //println(i"$this & $that")
       ctx.typeComparer.glb(this, that)
     }
 
@@ -2200,6 +2201,7 @@ object Types {
   object AndType {
     def apply(tp1: Type, tp2: Type)(implicit ctx: Context) = {
       assert(tp1.isValueType && tp2.isValueType, i"$tp1 & $tp2 / " + s"$tp1 & $tp2")
+      //assert(tp1.typeSymbol.name.toString != "B" || tp2.typeSymbol.name.toString != "A")
       unchecked(tp1, tp2)
     }
     def unchecked(tp1: Type, tp2: Type)(implicit ctx: Context) = {

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

@@ -51,9 +51,11 @@ class TreePickler(pickler: TastyPickler) {
     }
   }
 
-  def rhs(tdef: TypeDef)(implicit ctx: Context) = 
+  def rhs(tdef: TypeDef)(implicit ctx: Context): Tree = 
     if (tdef.symbol.isClass) tdef.rhs
-    else tdef.rhs.withType(tdef.symbol.info)
+    else if (true) tdef.rhs.withType(tdef.symbol.info)
+    else TypePositions.adapt(tdef.rhs, tdef.symbol.info, tdef.tparams)
+
 
   private def pickleName(name: Name): Unit = writeNat(nameIndex(name).index)
   private def pickleName(name: TastyName): Unit = writeNat(nameIndex(name).index)
@@ -324,23 +326,7 @@ class TreePickler(pickler: TastyPickler) {
 
   /** Pickle positioned type associated with type tree `tpt`. */
   private def picklePosTypeOfTree(posType: Type, tpt: Tree)(implicit ctx: Context): Unit = {
-    def checkTypePositions() = {
-      val tree = TypePositions.toTree(posType)
-      val origRefs = TypePositions.refPositions(tpt)
-      val newRefs = TypePositions.refPositions(tree)
-      assert(TypePositions.refPositions(tpt).toSet subsetOf TypePositions.refPositions(tree).toSet,
-        i"""$tpt 
-           |--> 
-           |$posType 
-           |--> 
-           |$tree
-           |/ 
-           |${posType.toString}
-           |/
-           |${tree.toString}""")
-
-    }
-    if (false) checkTypePositions
+    if (false) TypePositions.checkTypePositions(posType, tpt)
     positioned.register(tpt, posType)
     pickleType(posType)
   }

src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -167,8 +167,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   //
   //    test/new/annot.scala
   //
-  // override def toText(annot: Annotation): Text = 
-  //   if (annot.tree.isEmpty) annot.toString else constrText(annot.tree)
+  override def toText(annot: Annotation): Text = 
+    if (annot.tree.isEmpty) annot.toString else super.toText(annot)//constrText(annot.tree)
 
   override def toText[T >: Untyped](tree: Tree[T]): Text = controlled {