Use positioned types when generating types

Author: odersky

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

@@ -6,12 +6,16 @@ import Contexts._, Types._, Symbols._, TypeApplications._, Decorators._
 import util.Positions._
 import ast._
 import Trees._, Names._, StdNames._
+import collection.mutable
+import Annotations.Annotation
 
 object TypePositions {
   import tpd._
 
   /** Encapsulates a type and the position of a corresponding tree */
-  case class Positioned(tp: Type, pos: Position) extends UncachedGroundType
+  case class PosAnnot(pos: Position) extends Annotation {
+    def tree(implicit ctx: Context) = EmptyTree
+  }
 
   /** An object to handle the point positions of definitions */
   private object PointPos {
@@ -20,10 +24,10 @@ object TypePositions {
      *  the position.
      */
     def add(tree: Tree, tpe: Type) = tpe match {
-      case Positioned(tpe1, pos) if !tree.pos.isSynthetic =>
+      case AnnotatedType(tpe1, PosAnnot(pos)) if !tree.pos.isSynthetic && false =>
         val pointDelta = pos.start - tree.pos.point
-        assert(pointDelta > 0)
-        Positioned(tpe1, pos.withPoint(pos.start + pointDelta))
+        assert(pointDelta >= 0, s"$pos / ${tree.pos} / $tpe")
+        AnnotatedType(tpe1, PosAnnot(pos.withPoint(pos.start + pointDelta)))
       case _ => tpe
     }
 
@@ -43,35 +47,37 @@ object TypePositions {
     def unapply[T](xs: List[T]) = 
       if (xs.isEmpty) None else Some((xs.init, xs.last))
   }
-  
+
+  private def stripPos(tpe: Type) = tpe match {
+    case AnnotatedType(tpe1, _: PosAnnot) => tpe1
+    case _ => tpe
+  }
+
   /** Given a type tree, produce the corresponding type with positions added */
   def toType(tree: Tree)(implicit ctx: Context): Type = {
 
-    def stripPos(tpe: Type) = tpe match {
-      case Positioned(tpe1, _) => tpe1
-      case _ => tpe
-    }
-    
     def convertList(trees: List[Tree], tpes: List[Type]): List[Type] = 
       tpes.zipWithConserve(trees)((tpe, tree) => convert(tree, tpe))
 
     def convert(tree: Tree, tpe: Type): Type = {
-       val tpe1 = (tree, tpe) match {
+       val tpe1: Type = (tree, tpe.stripTypeVar) match {
         case (Select(qual, name), tpe: NamedType) if tpe.name == name =>
           tpe.derivedSelect(convert(qual, tpe.prefix))
-        case (SingletonTypeTree(ref), _) => 
+        case (SingletonTypeTree(ref), tpe) => 
           convert(ref, tpe)
         case (AndTypeTree(ltree, rtree), tpe @ AndType(ltpe, rtpe)) =>
           tpe.derivedAndType(convert(ltree, ltpe), convert(rtree, rtpe))
         case (OrTypeTree(ltree, rtree), tpe @ OrType(ltpe, rtpe)) =>
           tpe.derivedOrType(convert(ltree, ltpe), convert(rtree, rtpe))
+        case (rtree: RefinedTypeTree, tpe: RecType) =>
+          tpe.derivedRecType(convert(rtree, tpe.parent))
         case (RefinedTypeTree(ptree, Append(refinements, refinement: MemberDef)), 
               tpe @ RefinedType(ptpe, rname, rinfo)) if rname == refinement.name =>
           val parent = 
             if (refinements.isEmpty) ptree
             else cpy.RefinedTypeTree(tree)(ptree, refinements).withPos(NoPosition)
           tpe.derivedRefinedType(convert(parent, ptpe), rname, convert(refinement, rinfo))
-        case (AppliedTypeTree(ftree, argtrees), AppliedType(ftpe, argtpes)) =>
+        case (AppliedTypeTree(ftree, argtrees), AppliedType(ftpe, argtpes)) if argtrees.length == argtpes.length =>
           val ftpe1 = convert(ftree, ftpe)
           val argtpes1 = convertList(argtrees, argtpes)
           if ((ftpe1 eq ftpe) && (argtpes1 eq argtpes)) tpe
@@ -89,11 +95,15 @@ object TypePositions {
               tpe.paramNames, 
               convertList(tparams, tpe.paramBounds).map(t => stripPos(t).bounds), 
               convert(body, tpe.resultType))
-        case (TypeDef(name, rhs), _) =>
+        case (TypeDef(name, rhs), tpe @ TypeAlias(alias)) =>
+          PointPos.add(tree, tpe.derivedTypeAlias(convert(rhs, alias)))
+        case (TypeDef(name, rhs), tpe) =>
           PointPos.add(tree, convert(rhs, tpe))
-        case (ValDef(name, tpt, _), _) =>
+        case (ValDef(name, tpt, _), tpe) =>
           PointPos.add(tree, convert(tpt, tpe))
-        case (DefDef(name, Nil, Nil, tpt, _), _) => 
+        case (DefDef(name, Nil, Nil, tpt, _), tpe @ ExprType(rtpe)) => 
+          PointPos.add(tree, tpe.derivedExprType(convert(tpt, rtpe)))
+        case (DefDef(name, Nil, Nil, tpt, _), tpe) => 
           PointPos.add(tree, convert(tpt, tpe))
         case (tree @ DefDef(name, Nil, vparams :: vparamss1, tpt, _), tpe: MethodType) =>
           PointPos.add(tree, 
@@ -107,12 +117,12 @@ object TypePositions {
               tpe.paramNames, 
               convertList(tparams, tpe.paramBounds).map(t => stripPos(t).bounds), 
               convert(cpy.DefDef(tree)(tparams = Nil).withPos(NoPosition), tpe.resultType)))
-        case _ =>
+        case (_, tpe) =>
           tpe
       }
       tpe1 match {
-        case tpe1: Positioned => tpe1
-        case _ => if (tree.pos.exists) Positioned(tpe1, tree.pos) else tpe1
+        case AnnotatedType(_, _: PosAnnot) => tpe1
+        case _ => if (!tree.pos.isSynthetic) AnnotatedType(tpe1, PosAnnot(tree.pos)) else tpe1
       }
     }    
     convert(tree, tree.tpe)
@@ -124,18 +134,18 @@ object TypePositions {
     def typeTree = toTree(tpe)
     def untpdDef(tpe: Type): untpd.MemberDef = {
       import untpd._
-      tpe match {
+      stripPos(tpe) match {
         case tpe: PolyType =>
           def tparamTrees = (tpe.paramNames, tpe.paramBounds).zipped.map(toDef).asInstanceOf[List[TypeDef]]
-          untpdDef(tpe.resultType) match {
+          toDef(name, tpe.resultType) match {
             case mdef1: DefDef =>
               cpy.DefDef(mdef1)(tparams = tparamTrees)
             case mdef1: ValDef =>
               DefDef(mdef1.name, tparamTrees, Nil, mdef1.tpt, EmptyTree)
           }
         case tpe: MethodType =>
           def vparamTrees = (tpe.paramNames, tpe.paramTypes).zipped.map(toDef).asInstanceOf[List[ValDef]]
-          untpdDef(tpe.resultType) match {
+          toDef(name, tpe.resultType) match {
             case mdef1: DefDef =>
               cpy.DefDef(mdef1)(vparamss = vparamTrees :: mdef1.vparamss)
             case mdef1: ValDef =>
@@ -148,9 +158,9 @@ object TypePositions {
           }
       }
     }
-    val tpdDef = untpdDef(tpe).withType(defn.AnyType)
+    val tpdDef = untpdDef(tpe).withType(NoPrefix)
     tpe match {
-      case Positioned(tpe1, pos) => tpdDef.withPos(PointPos.defPos(pos))
+      case AnnotatedType(tpe1, PosAnnot(pos)) => tpdDef.withPos(PointPos.defPos(pos))
       case _ => tpdDef
     }
   }
@@ -173,8 +183,13 @@ object TypePositions {
    *  In each case, the tree's type is `tpe`.
    */
   def toTree(tpe: Type, hasPos: Boolean = false)(implicit ctx: Context): Tree = tpe match {
-    case Positioned(tpe1, pos) =>
-      toTree(tpe1, hasPos = true).withPos(pos.toSynthetic)
+    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
+      }
+      tree.withPos(pos.toSynthetic)
     case tpe =>
       val utree: untpd.Tree = {
         import untpd._
@@ -200,6 +215,8 @@ object TypePositions {
             This(tpnme.EMPTY)
           case tpe: ParamType if hasPos =>
             Ident(tpe.paramName)
+          case tpe: RecType => 
+            toTree(tpe.parent, hasPos)
           case AppliedType(tycon, args) =>
             mkTree(tycon) { AppliedTypeTree(_, args.map(toTree(_))) }
           case RefinedType(parent, rname, rinfo) =>
@@ -210,10 +227,20 @@ object TypePositions {
               case tpt =>
                 RefinedTypeTree(tpt, toRefinement(rname, rinfo) :: Nil)
             }
-          case tpe: RecType => 
-            toTree(tpe.parent, hasPos)
           case TypeBounds(lo, hi) =>
-            mkTree(lo) { TypeBoundsTree(_, toTree(hi)) }
+            def toTreeOrEmpty(tpe: Type, cls: Symbol): Tree = {
+              val tree = toTree(tpe)
+              tpe match {
+                case AnnotatedType(_, PosAnnot(pos)) if pos.start == pos.end && tree.tpe.isRef(cls) =>
+                  EmptyTree.withPos(pos)
+                case _ =>
+                  tree
+              }
+            }
+            toTreeOrEmpty(lo, defn.NothingClass) match {
+              case tpt: TypeTree => tpt
+              case lotree => TypeBoundsTree(lotree, toTreeOrEmpty(hi, defn.AnyClass))
+            }
           case tpe: ExprType =>
             mkTree(tpe.resType) { ByNameTypeTree(_) }
           case tpe: PolyType =>
@@ -235,4 +262,13 @@ object TypePositions {
       }
       utree.withType(tpe)
   }
+  
+  def refPositions(tree: Tree)(implicit ctx: Context): List[(Name, Position)] = {
+    val b = new mutable.ListBuffer[(Name, Position)]
+    tree foreachSubTree {
+      case t: RefTree => b += ((t.name, t.pos.toSynthetic))
+      case _ =>
+    }
+    b.toList  
+  }
 }

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

@@ -7,6 +7,8 @@ import util.Util.{bestFit, dble}
 import TastyBuffer.{Addr, AddrWidth}
 import config.Printers.pickling
 import ast.untpd.Tree
+import ast.TypePositions.PosAnnot
+import Types.Type
 
 class TreeBuffer extends TastyBuffer(50000) {
 
@@ -18,13 +20,15 @@ class TreeBuffer extends TastyBuffer(50000) {
   private var numOffsets = 0
 
   private type TreeAddrs = Any // really: Addr | List[Addr]
-
+  
+  private type Addressed = Any // really: Tree | Positioned  
+  
   /** A map from trees to the address(es) at which a tree is pickled. There may be several
    *  such addresses if the tree is shared. To keep the map compact, the value type is a
    *  disjunction of a single address (which is the common case) and a list of addresses.
    */
-  private val treeAddrs = new java.util.IdentityHashMap[Tree, TreeAddrs]
-
+  private val treeAddrs = new java.util.IdentityHashMap[Addressed, TreeAddrs]
+  
   def registerTreeAddr(tree: Tree) =
     treeAddrs.put(tree,
       treeAddrs.get(tree) match {
@@ -39,6 +43,8 @@ class TreeBuffer extends TastyBuffer(50000) {
     case addrs: List[Addr] => addrs
   }
 
+  val posTypeOfTree = new java.util.IdentityHashMap[Tree, Type]
+  
   private def offset(i: Int): Addr = Addr(offsets(i))
 
   private def keepOffset(relative: Boolean): Unit = {

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

@@ -4,7 +4,8 @@ package core
 package tasty
 
 import ast.Trees._
-import ast.untpd
+import ast.{untpd, TypePositions}
+import TypePositions.PosAnnot
 import TastyFormat._
 import Contexts._, Symbols._, Types._, Names._, Constants._, Decorators._, Annotations._, StdNames.tpnme, NameOps._
 import collection.mutable
@@ -52,7 +53,7 @@ class TreePickler(pickler: TastyPickler) {
 
   def rhs(tdef: TypeDef)(implicit ctx: Context) = 
     if (tdef.symbol.isClass) tdef.rhs
-    else TypeTree(tdef.symbol.info).withPos(tdef.rhs.pos)
+    else tdef.rhs.withType(tdef.symbol.info)
 
   private def pickleName(name: Name): Unit = writeNat(nameIndex(name).index)
   private def pickleName(name: TastyName): Unit = writeNat(nameIndex(name).index)
@@ -140,21 +141,26 @@ class TreePickler(pickler: TastyPickler) {
       pickleType(c.symbolValue.termRef)
   }
 
-  def pickleType(tpe0: Type, richTypes: Boolean = false)(implicit ctx: Context): Unit = try {
-    val tpe = tpe0.stripTypeVar
-    val prev = pickledTypes.get(tpe)
-    if (prev == null) {
-      pickledTypes.put(tpe, currentAddr)
-      pickleNewType(tpe, richTypes)
-    }
-    else {
-      writeByte(SHARED)
-      writeRef(prev.asInstanceOf[Addr])
-    }
-  } catch {
-    case ex: AssertionError =>
-      println(i"error when pickling type $tpe0")
-      throw ex
+  def pickleType(tpe0: Type, richTypes: Boolean = false)(implicit ctx: Context): Unit = tpe0 match {
+    case AnnotatedType(tpe1, PosAnnot(pos)) =>
+      pickleType(tpe1, richTypes)
+    case _ =>
+      try {
+        val tpe = tpe0.stripTypeVar
+        val prev = pickledTypes.get(tpe)
+        if (prev == null) {
+          pickledTypes.put(tpe, currentAddr)
+          pickleNewType(tpe, richTypes)
+        } else {
+          writeByte(SHARED)
+          writeRef(prev.asInstanceOf[Addr])
+        }
+      } 
+      catch {
+        case ex: AssertionError =>
+          println(i"error when pickling type $tpe0")
+          throw ex
+      }
   }
 
   def pickleTypeWithPos(tpe: Type, tree: Tree)(implicit ctx: Context): Unit = {
@@ -308,9 +314,36 @@ class TreePickler(pickler: TastyPickler) {
     }
     pickled
   }
+  
+  def pickleTpt(tpt: Tree)(implicit ctx: Context): Unit = tpt match {
+    case _: TypeTree => pickleTypeWithPos(tpt.tpe, tpt)
+    case _ => 
+      val posType = TypePositions.toType(tpt)
+      
+      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}""")
 
-  def pickleTpt(tpt: Tree)(implicit ctx: Context): Unit =
-    pickleTypeWithPos(tpt.tpe, tpt) // TODO correlate with original when generating positions
+      }
+      if (false) checkTypePositions
+      
+      posType match {
+        case pd @ AnnotatedType(_, _: PosAnnot) => posTypeOfTree.put(tpt, pd)
+        case _ => 
+      }
+      pickleTypeWithPos(posType, tpt)
+  }
 
   def pickleTreeUnlessEmpty(tree: Tree)(implicit ctx: Context): Unit =
     if (!tree.isEmpty) pickleTree(tree)

src/dotty/tools/dotc/transform/ExtensionMethods.scala

@@ -1,7 +1,3 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author Martin Odersky
- */
 package dotty.tools.dotc
 package transform
 

src/dotty/tools/dotc/transform/PostTyper.scala

@@ -122,7 +122,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer  { thisTran
         case _ =>
           val tree1 = super.transform(tree)
           constToLiteral(tree1) match {
-            case _: Literal => tree1
+            case _: Literal => tree1 // keep tree, no need to transform super accessor
             case _ => superAcc.transformSelect(tree1, targs)
           }
       }