refactors importers

Introduces better names, factors out recreation of symbols, trees, types
and completes into separate methods, so that they can be overridden in
specialized importers.

The original motivation for this refactoring was to support JIT
compilation of macros, but I think that most of the introduced
improvements to code quality will be useful in trunk.

1 files changed, 318 insertions, 318 deletions

diff --git a/src/reflect/scala/reflect/internal/Importers.scala b/src/reflect/scala/reflect/internal/Importers.scala
index b0d3cda629..ae1c2a9a77 100644
--- a/src/reflect/scala/reflect/internal/Importers.scala
+++ b/src/reflect/scala/reflect/internal/Importers.scala
@@ -6,17 +6,17 @@ import scala.collection.mutable.WeakHashMap
 import scala.ref.WeakReference
 
 // SI-6241: move importers to a mirror
-trait Importers extends api.Importers { self: SymbolTable =>
+trait Importers extends api.Importers { to: SymbolTable =>
 
   def mkImporter(from0: api.Universe): Importer { val from: from0.type } = (
-    if (self eq from0) {
+    if (to eq from0) {
       new Importer {
         val from = from0
-        val reverse = this.asInstanceOf[from.Importer{ val from: self.type }]
-        def importSymbol(sym: from.Symbol) = sym.asInstanceOf[self.Symbol]
-        def importType(tpe: from.Type) = tpe.asInstanceOf[self.Type]
-        def importTree(tree: from.Tree) = tree.asInstanceOf[self.Tree]
-        def importPosition(pos: from.Position) = pos.asInstanceOf[self.Position]
+        val reverse = this.asInstanceOf[from.Importer{ val from: to.type }]
+        def importSymbol(their: from.Symbol) = their.asInstanceOf[to.Symbol]
+        def importType(their: from.Type) = their.asInstanceOf[to.Type]
+        def importTree(their: from.Tree) = their.asInstanceOf[to.Tree]
+        def importPosition(their: from.Position) = their.asInstanceOf[to.Position]
       }
     } else {
       // todo. fix this loophole
@@ -29,8 +29,8 @@ trait Importers extends api.Importers { self: SymbolTable =>
 
     val from: SymbolTable
 
-    protected lazy val symMap = new Cache[from.Symbol, Symbol]()
-    protected lazy val tpeMap = new Cache[from.Type, Type]()
+    protected lazy val symMap = new Cache[from.Symbol, to.Symbol]()
+    protected lazy val tpeMap = new Cache[from.Type, to.Type]()
     protected class Cache[K <: AnyRef, V <: AnyRef] extends WeakHashMap[K, WeakReference[V]] {
       def weakGet(key: K): Option[V] = this get key flatMap WeakReference.unapply
       def weakUpdate(key: K, value: V) = this.update(key, WeakReference(value))
@@ -50,158 +50,156 @@ trait Importers extends api.Importers { self: SymbolTable =>
     }
 
     object reverse extends from.StandardImporter {
-      val from: self.type = self
+      val from: to.type = to
       // FIXME this and reverse should be constantly kept in sync
       // not just synced once upon the first usage of reverse
-      for ((fromsym, WeakReference(mysym)) <- StandardImporter.this.symMap) symMap += ((mysym, WeakReference(fromsym)))
-      for ((fromtpe, WeakReference(mytpe)) <- StandardImporter.this.tpeMap) tpeMap += ((mytpe, WeakReference(fromtpe)))
+      for ((theirsym, WeakReference(mysym)) <- StandardImporter.this.symMap) symMap += ((mysym, WeakReference(theirsym)))
+      for ((theirtpe, WeakReference(mytpe)) <- StandardImporter.this.tpeMap) tpeMap += ((mytpe, WeakReference(theirtpe)))
     }
 
-    // todo. careful import of positions
-    def importPosition(pos: from.Position): Position =
-      pos.asInstanceOf[Position]
+    // ============== SYMBOLS ==============
 
-    def importSymbol(sym0: from.Symbol): Symbol = {
-      def doImport(sym: from.Symbol): Symbol =
-        symMap weakGet sym match {
+    protected def recreatedSymbolCompleter(their: from.Symbol) = {
+      val mytypeParams = their.typeParams map importSymbol
+      new LazyPolyType(mytypeParams) with FlagAgnosticCompleter {
+        override def complete(my: to.Symbol): Unit = {
+          val theirCore = their.info match {
+            case from.PolyType(_, core) => core
+            case core => core
+          }
+          my setInfo GenPolyType(mytypeParams, importType(theirCore))
+          my setAnnotations (their.annotations map importAnnotationInfo)
+        }
+      }
+    }
+
+    protected def recreateSymbol(their: from.Symbol): to.Symbol = {
+      val myowner = importSymbol(their.owner)
+      val mypos   = importPosition(their.pos)
+      val myname  = importName(their.name)
+      val myflags = their.flags
+      def linkReferenced(my: TermSymbol, their: from.TermSymbol, op: from.Symbol => Symbol): Symbol = {
+        symMap.weakUpdate(their, my)
+        my.referenced = op(their.referenced)
+        my
+      }
+      val my = their match {
+        case their: from.MethodSymbol =>
+          linkReferenced(myowner.newMethod(myname.toTermName, mypos, myflags), their, importSymbol)
+        case their: from.ModuleSymbol =>
+          val ret = linkReferenced(myowner.newModuleSymbol(myname.toTermName, mypos, myflags), their, importSymbol)
+          ret.associatedFile = their.associatedFile
+          ret
+        case their: from.FreeTermSymbol =>
+          newFreeTermSymbol(myname.toTermName, their.value, their.flags, their.origin) setInfo importType(their.info)
+        case their: from.FreeTypeSymbol =>
+          newFreeTypeSymbol(myname.toTypeName, their.flags, their.origin)
+        case their: from.TermSymbol =>
+          linkReferenced(myowner.newValue(myname.toTermName, mypos, myflags), their, importSymbol)
+        case their: from.TypeSkolem =>
+          val origin = their.unpackLocation match {
+            case null                  => null
+            case theirloc: from.Tree   => importTree(theirloc)
+            case theirloc: from.Symbol => importSymbol(theirloc)
+          }
+          myowner.newTypeSkolemSymbol(myname.toTypeName, origin, mypos, myflags)
+        case their: from.ModuleClassSymbol =>
+          val my = myowner.newModuleClass(myname.toTypeName, mypos, myflags)
+          symMap.weakUpdate(their, my)
+          my.sourceModule = importSymbol(their.sourceModule)
+          my
+        case their: from.ClassSymbol =>
+          val my = myowner.newClassSymbol(myname.toTypeName, mypos, myflags)
+          symMap.weakUpdate(their, my)
+          if (their.thisSym != their) {
+            my.typeOfThis = importType(their.typeOfThis)
+            my.thisSym setName importName(their.thisSym.name)
+          }
+          my.associatedFile = their.associatedFile
+          my
+        case their: from.TypeSymbol =>
+          myowner.newTypeSymbol(myname.toTypeName, mypos, myflags)
+      }
+      symMap.weakUpdate(their, my)
+      my setFlag Flags.LOCKED
+      my setInfo recreatedSymbolCompleter(their)
+      my resetFlag Flags.LOCKED
+    }
+
+    def importSymbol(their0: from.Symbol): Symbol = {
+      def cachedRecreateSymbol(their: from.Symbol): Symbol =
+        symMap weakGet their match {
           case Some(result) => result
-          case _ =>
-            val myowner = importSymbol(sym.owner)
-            val mypos   = importPosition(sym.pos)
-            val myname  = importName(sym.name).toTermName
-            val myflags = sym.flags
-            def linkReferenced(mysym: TermSymbol, x: from.TermSymbol, op: from.Symbol => Symbol): Symbol = {
-              symMap.weakUpdate(x, mysym)
-              mysym.referenced = op(x.referenced)
-              mysym
-            }
-            val mysym = sym match {
-              case x: from.MethodSymbol =>
-                linkReferenced(myowner.newMethod(myname, mypos, myflags), x, importSymbol)
-              case x: from.ModuleSymbol =>
-                linkReferenced(myowner.newModuleSymbol(myname, mypos, myflags), x, importSymbol)
-              case x: from.FreeTermSymbol =>
-                newFreeTermSymbol(importName(x.name).toTermName, x.value, x.flags, x.origin) setInfo importType(x.info)
-              case x: from.FreeTypeSymbol =>
-                newFreeTypeSymbol(importName(x.name).toTypeName, x.flags, x.origin)
-              case x: from.TermSymbol =>
-                linkReferenced(myowner.newValue(myname, mypos, myflags), x, importSymbol)
-              case x: from.TypeSkolem =>
-                val origin = x.unpackLocation match {
-                  case null           => null
-                  case y: from.Tree   => importTree(y)
-                  case y: from.Symbol => importSymbol(y)
-                }
-                myowner.newTypeSkolemSymbol(myname.toTypeName, origin, mypos, myflags)
-              case x: from.ModuleClassSymbol =>
-                val mysym = myowner.newModuleClass(myname.toTypeName, mypos, myflags)
-                symMap.weakUpdate(x, mysym)
-                mysym.sourceModule = importSymbol(x.sourceModule)
-                mysym
-              case x: from.ClassSymbol =>
-                val mysym = myowner.newClassSymbol(myname.toTypeName, mypos, myflags)
-                symMap.weakUpdate(x, mysym)
-                if (sym.thisSym != sym) {
-                  mysym.typeOfThis = importType(sym.typeOfThis)
-                  mysym.thisSym setName importName(sym.thisSym.name)
-                }
-                mysym
-              case x: from.TypeSymbol =>
-                myowner.newTypeSymbol(myname.toTypeName, mypos, myflags)
-            }
-            symMap.weakUpdate(sym, mysym)
-            mysym setFlag Flags.LOCKED
-            mysym setInfo {
-              val mytypeParams = sym.typeParams map importSymbol
-              new LazyPolyType(mytypeParams) with FlagAgnosticCompleter {
-                override def complete(s: Symbol) {
-                  val result = sym.info match {
-                    case from.PolyType(_, res) => res
-                    case result => result
-                  }
-                  s setInfo GenPolyType(mytypeParams, importType(result))
-                  s setAnnotations (sym.annotations map importAnnotationInfo)
-                }
-              }
-            }
-            mysym resetFlag Flags.LOCKED
-        } // end doImport
+          case _ => recreateSymbol(their)
+        }
 
-      def importOrRelink: Symbol = {
-        val sym = sym0 // makes sym visible in the debugger
-        if (sym == null)
+      def recreateOrRelink: Symbol = {
+        val their = their0 // makes their visible in the debugger
+        if (their == null)
           null
-        else if (sym == from.NoSymbol)
+        else if (their == from.NoSymbol)
           NoSymbol
-        else if (sym.isRoot)
+        else if (their.isRoot)
           rootMirror.RootClass // !!! replace with actual mirror when we move importers to the mirror
         else {
-          val name = sym.name
-          val owner = sym.owner
-          var scope = if (owner.isClass && !owner.isRefinementClass) owner.info else from.NoType
-          var existing = scope.decl(name)
-          if (sym.isModuleClass)
-            existing = existing.moduleClass
-
-          if (!existing.exists) scope = from.NoType
-
-          val myname = importName(name)
-          val myowner = importSymbol(owner)
-          val myscope = if (scope != from.NoType && !(myowner hasFlag Flags.LOCKED)) myowner.info else NoType
-          var myexisting = if (myscope != NoType) myowner.info.decl(myname) else NoSymbol // cannot load myexisting in general case, because it creates cycles for methods
-          if (sym.isModuleClass)
-            myexisting = importSymbol(sym.sourceModule).moduleClass
-
-          if (!sym.isOverloaded && myexisting.isOverloaded) {
+          var theirscope = if (their.owner.isClass && !their.owner.isRefinementClass) their.owner.info else from.NoType
+          var theirexisting = theirscope.decl(their.name)
+          if (their.isModuleClass) theirexisting = theirexisting.moduleClass
+          if (!theirexisting.exists) theirscope = from.NoType
+
+          val myname = importName(their.name)
+          val myowner = importSymbol(their.owner)
+          val myscope = if (theirscope != from.NoType && !(myowner hasFlag Flags.LOCKED)) myowner.info else NoType
+          var myexisting = if (myscope != NoType) myscope.decl(myname) else NoSymbol // cannot load myexisting in general case, because it creates cycles for methods
+
+          if (their.isModuleClass)
+            myexisting = importSymbol(their.sourceModule).moduleClass
+
+          if (!their.isOverloaded && myexisting.isOverloaded) {
             myexisting =
-              if (sym.isMethod) {
-                val localCopy = doImport(sym)
+              if (their.isMethod) {
+                val localCopy = cachedRecreateSymbol(their)
                 myexisting filter (_.tpe matches localCopy.tpe)
               } else {
                 myexisting filter (!_.isMethod)
               }
             assert(!myexisting.isOverloaded,
                 "import failure: cannot determine unique overloaded method alternative from\n "+
-                (myexisting.alternatives map (_.defString) mkString "\n")+"\n that matches "+sym+":"+sym.tpe)
+                (myexisting.alternatives map (_.defString) mkString "\n")+"\n that matches "+their+":"+their.tpe)
           }
 
-          val mysym = {
-            if (sym.isOverloaded) {
-              myowner.newOverloaded(myowner.thisType, sym.alternatives map importSymbol)
-            } else if (sym.isTypeParameter && sym.paramPos >= 0 && !(myowner hasFlag Flags.LOCKED)) {
-              assert(myowner.typeParams.length > sym.paramPos,
-                  "import failure: cannot determine parameter "+sym+" (#"+sym.paramPos+") in "+
+          val my = {
+            if (their.isOverloaded) {
+              myowner.newOverloaded(myowner.thisType, their.alternatives map importSymbol)
+            } else if (their.isTypeParameter && their.paramPos >= 0 && !(myowner hasFlag Flags.LOCKED)) {
+              assert(myowner.typeParams.length > their.paramPos,
+                  "import failure: cannot determine parameter "+their+" (#"+their.paramPos+") in "+
                   myowner+typeParamsString(myowner.rawInfo)+"\n original symbol was: "+
-                  sym.owner+from.typeParamsString(sym.owner.info))
-              myowner.typeParams(sym.paramPos)
+                  their.owner+from.typeParamsString(their.owner.info))
+              myowner.typeParams(their.paramPos)
             } else {
-              if (myexisting != NoSymbol) {
-                myexisting
-              } else {
-                val mysym = doImport(sym)
-
+              myexisting.orElse {
+                val my = cachedRecreateSymbol(their)
                 if (myscope != NoType) {
-                  assert(myowner.info.decls.lookup(myname) == NoSymbol, myname+" "+myowner.info.decl(myname)+" "+myexisting)
-                  myowner.info.decls enter mysym
+                  assert(myscope.decls.lookup(myname) == NoSymbol, myname+" "+myscope.decl(myname)+" "+myexisting)
+                  myscope.decls enter my
                 }
-
-                mysym
+                my
               }
             }
           }
-
-          mysym
+          my
         }
-      } // end importOrRelink
+      } // end recreateOrRelink
 
-      val sym = sym0
-      symMap.weakGet(sym) match {
+      val their = their0
+      symMap.weakGet(their) match {
         case Some(result) => result
         case None =>
           pendingSyms += 1
           try {
-            val result = importOrRelink
-            symMap.weakUpdate(sym, result)
+            val result = recreateOrRelink
+            symMap.weakUpdate(their, result)
             result
           } finally {
             pendingSyms -= 1
@@ -210,69 +208,70 @@ trait Importers extends api.Importers { self: SymbolTable =>
       }
     }
 
-    def importType(tpe: from.Type): Type = {
-      def doImport(tpe: from.Type): Type = tpe match {
-        case from.TypeRef(pre, sym, args) =>
-          TypeRef(importType(pre), importSymbol(sym), args map importType)
-        case from.ThisType(clazz) =>
-          ThisType(importSymbol(clazz))
-        case from.SingleType(pre, sym) =>
-          SingleType(importType(pre), importSymbol(sym))
-        case from.MethodType(params, restpe) =>
-          MethodType(params map importSymbol, importType(restpe))
-        case from.PolyType(tparams, restpe) =>
-          PolyType(tparams map importSymbol, importType(restpe))
-        case from.NullaryMethodType(restpe) =>
-          NullaryMethodType(importType(restpe))
-        case from.ConstantType(constant @ from.Constant(_)) =>
-          ConstantType(importConstant(constant))
-        case from.SuperType(thistpe, supertpe) =>
-          SuperType(importType(thistpe), importType(supertpe))
-        case from.TypeBounds(lo, hi) =>
-          TypeBounds(importType(lo), importType(hi))
-        case from.BoundedWildcardType(bounds) =>
-          BoundedWildcardType(importTypeBounds(bounds))
-        case from.ClassInfoType(parents, decls, clazz) =>
-          val myclazz = importSymbol(clazz)
-          val myscope = if (myclazz.isPackageClass) newPackageScope(myclazz) else newScope
-          val myclazzTpe = ClassInfoType(parents map importType, myscope, myclazz)
-          myclazz setInfo GenPolyType(myclazz.typeParams, myclazzTpe) // needed so that newly created symbols find their scope
-          decls foreach importSymbol // will enter itself into myclazz
-          myclazzTpe
-        case from.RefinedType(parents, decls) =>
-          RefinedType(parents map importType, importScope(decls), importSymbol(tpe.typeSymbol))
-        case from.ExistentialType(tparams, restpe) =>
-          newExistentialType(tparams map importSymbol, importType(restpe))
-        case from.OverloadedType(pre, alts) =>
-          OverloadedType(importType(pre), alts map importSymbol)
-        case from.AntiPolyType(pre, targs) =>
-          AntiPolyType(importType(pre), targs map importType)
-        case x: from.TypeVar =>
-          TypeVar(importType(x.origin), importTypeConstraint(x.constr), x.typeArgs map importType, x.params map importSymbol)
-        case from.AnnotatedType(annots, tpe, selfsym) =>
-          AnnotatedType(annots map importAnnotationInfo, importType(tpe), importSymbol(selfsym))
-        case from.ErrorType =>
-          ErrorType
-        case from.WildcardType =>
-          WildcardType
-        case from.NoType =>
-          NoType
-        case from.NoPrefix =>
-          NoPrefix
-        case null =>
-          null
-      } // end doImport
-
-      def importOrRelink: Type =
-        doImport(tpe)
+    // ============== TYPES ==============
+
+    def recreateType(their: from.Type): Type = their match {
+      case from.TypeRef(pre, sym, args) =>
+        TypeRef(importType(pre), importSymbol(sym), args map importType)
+      case from.ThisType(clazz) =>
+        ThisType(importSymbol(clazz))
+      case from.SingleType(pre, sym) =>
+        SingleType(importType(pre), importSymbol(sym))
+      case from.MethodType(params, result) =>
+        MethodType(params map importSymbol, importType(result))
+      case from.PolyType(tparams, result) =>
+        PolyType(tparams map importSymbol, importType(result))
+      case from.NullaryMethodType(result) =>
+        NullaryMethodType(importType(result))
+      case from.ConstantType(constant @ from.Constant(_)) =>
+        ConstantType(importConstant(constant))
+      case from.SuperType(thistpe, supertpe) =>
+        SuperType(importType(thistpe), importType(supertpe))
+      case from.TypeBounds(lo, hi) =>
+        TypeBounds(importType(lo), importType(hi))
+      case from.BoundedWildcardType(bounds) =>
+        BoundedWildcardType(importType(bounds).asInstanceOf[TypeBounds])
+      case from.ClassInfoType(parents, decls, clazz) =>
+        val myclazz = importSymbol(clazz)
+        val myscope = if (myclazz.isPackageClass) newPackageScope(myclazz) else newScope
+        val myclazzTpe = ClassInfoType(parents map importType, myscope, myclazz)
+        myclazz setInfo GenPolyType(myclazz.typeParams, myclazzTpe) // needed so that newly created symbols find their scope
+        decls foreach importSymbol // will enter itself into myclazz
+        myclazzTpe
+      case from.RefinedType(parents, decls) =>
+        RefinedType(parents map importType, importScope(decls), importSymbol(their.typeSymbol))
+      case from.ExistentialType(tparams, result) =>
+        newExistentialType(tparams map importSymbol, importType(result))
+      case from.OverloadedType(pre, alts) =>
+        OverloadedType(importType(pre), alts map importSymbol)
+      case from.AntiPolyType(pre, targs) =>
+        AntiPolyType(importType(pre), targs map importType)
+      case their: from.TypeVar =>
+        val myconstr = new TypeConstraint(their.constr.loBounds map importType, their.constr.hiBounds map importType)
+        myconstr.inst = importType(their.constr.inst)
+        TypeVar(importType(their.origin), myconstr, their.typeArgs map importType, their.params map importSymbol)
+      case from.AnnotatedType(annots, result, selfsym) =>
+        AnnotatedType(annots map importAnnotationInfo, importType(result), importSymbol(selfsym))
+      case from.ErrorType =>
+        ErrorType
+      case from.WildcardType =>
+        WildcardType
+      case from.NoType =>
+        NoType
+      case from.NoPrefix =>
+        NoPrefix
+      case null =>
+        null
+    }
 
-      tpeMap.weakGet(tpe) match {
+    def importType(their: from.Type): Type = {
+      tpeMap.weakGet(their) match {
         case Some(result) => result
         case None =>
           pendingTpes += 1
           try {
-            val result = importOrRelink
-            tpeMap.weakUpdate(tpe, result)
+            val result = recreateType(their)
+            tpeMap.weakUpdate(their, result)
             result
           } finally {
             pendingTpes -= 1
@@ -281,7 +280,136 @@ trait Importers extends api.Importers { self: SymbolTable =>
       }
     }
 
-    def importTypeBounds(bounds: from.TypeBounds) = importType(bounds).asInstanceOf[TypeBounds]
+    // ============== TREES ==============
+
+    def recreatedTreeCompleter(their: from.Tree, my: to.Tree): Unit = {
+      if (their.canHaveAttrs) {
+        if (my.hasSymbolField) my.symbol = importSymbol(their.symbol)
+        my.pos = importPosition(their.pos)
+        (their, my) match {
+          case (their: from.TypeTree, my: to.TypeTree) =>
+            if (their.wasEmpty) my.defineType(importType(their.tpe)) else my.setType(importType(their.tpe))
+          case (_, _) =>
+            my.tpe = importType(their.tpe)
+        }
+      }
+    }
+
+    def recreateTree(their: from.Tree): to.Tree = their match {
+      case from.ClassDef(mods, name, tparams, impl) =>
+        new ClassDef(importModifiers(mods), importName(name).toTypeName, tparams map importTypeDef, importTemplate(impl))
+      case from.PackageDef(pid, stats) =>
+        new PackageDef(importRefTree(pid), stats map importTree)
+      case from.ModuleDef(mods, name, impl) =>
+        new ModuleDef(importModifiers(mods), importName(name).toTermName, importTemplate(impl))
+      case from.emptyValDef =>
+        emptyValDef
+      case from.pendingSuperCall =>
+        pendingSuperCall
+      case from.ValDef(mods, name, tpt, rhs) =>
+        new ValDef(importModifiers(mods), importName(name).toTermName, importTree(tpt), importTree(rhs))
+      case from.DefDef(mods, name, tparams, vparamss, tpt, rhs) =>
+        new DefDef(importModifiers(mods), importName(name).toTermName, tparams map importTypeDef, mmap(vparamss)(importValDef), importTree(tpt), importTree(rhs))
+      case from.TypeDef(mods, name, tparams, rhs) =>
+        new TypeDef(importModifiers(mods), importName(name).toTypeName, tparams map importTypeDef, importTree(rhs))
+      case from.LabelDef(name, params, rhs) =>
+        new LabelDef(importName(name).toTermName, params map importIdent, importTree(rhs))
+      case from.Import(expr, selectors) =>
+        new Import(importTree(expr), selectors map importImportSelector)
+      case from.Template(parents, self, body) =>
+        new Template(parents map importTree, importValDef(self), body map importTree)
+      case from.Block(stats, expr) =>
+        new Block(stats map importTree, importTree(expr))
+      case from.CaseDef(pat, guard, body) =>
+        new CaseDef(importTree(pat), importTree(guard), importTree(body))
+      case from.Alternative(trees) =>
+        new Alternative(trees map importTree)
+      case from.Star(elem) =>
+        new Star(importTree(elem))
+      case from.Bind(name, body) =>
+        new Bind(importName(name), importTree(body))
+      case from.UnApply(fun, args) =>
+        new UnApply(importTree(fun), args map importTree)
+      case from.ArrayValue(elemtpt ,elems) =>
+        new ArrayValue(importTree(elemtpt), elems map importTree)
+      case from.Function(vparams, body) =>
+        new Function(vparams map importValDef, importTree(body))
+      case from.Assign(lhs, rhs) =>
+        new Assign(importTree(lhs), importTree(rhs))
+      case from.AssignOrNamedArg(lhs, rhs) =>
+        new AssignOrNamedArg(importTree(lhs), importTree(rhs))
+      case from.If(cond, thenp, elsep) =>
+        new If(importTree(cond), importTree(thenp), importTree(elsep))
+      case from.Match(selector, cases) =>
+        new Match(importTree(selector), cases map importCaseDef)
+      case from.Return(expr) =>
+        new Return(importTree(expr))
+      case from.Try(block, catches, finalizer) =>
+        new Try(importTree(block), catches map importCaseDef, importTree(finalizer))
+      case from.Throw(expr) =>
+        new Throw(importTree(expr))
+      case from.New(tpt) =>
+        new New(importTree(tpt))
+      case from.Typed(expr, tpt) =>
+        new Typed(importTree(expr), importTree(tpt))
+      case from.TypeApply(fun, args) =>
+        new TypeApply(importTree(fun), args map importTree)
+      case from.Apply(fun, args) => their match {
+        case _: from.ApplyToImplicitArgs =>
+          new ApplyToImplicitArgs(importTree(fun), args map importTree)
+        case _: from.ApplyImplicitView =>
+          new ApplyImplicitView(importTree(fun), args map importTree)
+        case _ =>
+          new Apply(importTree(fun), args map importTree)
+      }
+      case from.ApplyDynamic(qual, args) =>
+        new ApplyDynamic(importTree(qual), args map importTree)
+      case from.Super(qual, mix) =>
+        new Super(importTree(qual), importName(mix).toTypeName)
+      case from.This(qual) =>
+        new This(importName(qual).toTypeName)
+      case from.Select(qual, name) =>
+        new Select(importTree(qual), importName(name))
+      case from.Ident(name) =>
+        new Ident(importName(name))
+      case from.ReferenceToBoxed(ident) =>
+        new ReferenceToBoxed(importTree(ident) match { case ident: Ident => ident })
+      case from.Literal(constant @ from.Constant(_)) =>
+        new Literal(importConstant(constant))
+      case theirtt @ from.TypeTree() =>
+        val mytt = TypeTree()
+        if (theirtt.original != null) mytt.setOriginal(importTree(theirtt.original))
+        mytt
+      case from.Annotated(annot, arg) =>
+        new Annotated(importTree(annot), importTree(arg))
+      case from.SingletonTypeTree(ref) =>
+        new SingletonTypeTree(importTree(ref))
+      case from.SelectFromTypeTree(qual, name) =>
+        new SelectFromTypeTree(importTree(qual), importName(name).toTypeName)
+      case from.CompoundTypeTree(templ) =>
+        new CompoundTypeTree(importTemplate(templ))
+      case from.AppliedTypeTree(tpt, args) =>
+        new AppliedTypeTree(importTree(tpt), args map importTree)
+      case from.TypeBoundsTree(lo, hi) =>
+        new TypeBoundsTree(importTree(lo), importTree(hi))
+      case from.ExistentialTypeTree(tpt, whereClauses) =>
+        new ExistentialTypeTree(importTree(tpt), whereClauses map importTree)
+      case from.EmptyTree =>
+        EmptyTree
+      case null =>
+        null
+    }
+
+    def importTree(their: from.Tree): Tree = {
+      val my = recreateTree(their)
+      if (my != null) {
+        addFixup(recreatedTreeCompleter(their, my))
+        tryFixup()
+      }
+      my
+    }
+
+    // ============== MISCELLANEOUS ==============
 
     def importAnnotationInfo(ann: from.AnnotationInfo): AnnotationInfo = {
       val atp1 = importType(ann.atp)
@@ -302,11 +430,9 @@ trait Importers extends api.Importers { self: SymbolTable =>
         NestedAnnotArg(importAnnotationInfo(annInfo))
     }
 
-    def importTypeConstraint(constr: from.TypeConstraint): TypeConstraint = {
-      val result = new TypeConstraint(constr.loBounds map importType, constr.hiBounds map importType)
-      result.inst = importType(constr.inst)
-      result
-    }
+    // todo. careful import of positions
+    def importPosition(their: from.Position): to.Position =
+      their.asInstanceOf[Position]
 
     // !!! todo: override to cater for PackageScopes
     def importScope(decls: from.Scope): Scope =
@@ -314,138 +440,12 @@ trait Importers extends api.Importers { self: SymbolTable =>
 
     def importName(name: from.Name): Name =
       if (name.isTypeName) newTypeName(name.toString) else newTermName(name.toString)
-    def importTypeName(name: from.TypeName): TypeName = importName(name).toTypeName
 
     def importModifiers(mods: from.Modifiers): Modifiers =
       new Modifiers(mods.flags, importName(mods.privateWithin), mods.annotations map importTree)
 
     def importImportSelector(sel: from.ImportSelector): ImportSelector =
       new ImportSelector(importName(sel.name), sel.namePos, if (sel.rename != null) importName(sel.rename) else null, sel.renamePos)
-
-    def importTree(tree: from.Tree): Tree = {
-      val mytree = tree match {
-        case from.ClassDef(mods, name, tparams, impl) =>
-          new ClassDef(importModifiers(mods), importName(name).toTypeName, tparams map importTypeDef, importTemplate(impl))
-        case from.PackageDef(pid, stats) =>
-          new PackageDef(importRefTree(pid), stats map importTree)
-        case from.ModuleDef(mods, name, impl) =>
-          new ModuleDef(importModifiers(mods), importName(name).toTermName, importTemplate(impl))
-        case from.emptyValDef =>
-          emptyValDef
-        case from.pendingSuperCall =>
-          pendingSuperCall
-        case from.ValDef(mods, name, tpt, rhs) =>
-          new ValDef(importModifiers(mods), importName(name).toTermName, importTree(tpt), importTree(rhs))
-        case from.DefDef(mods, name, tparams, vparamss, tpt, rhs) =>
-          new DefDef(importModifiers(mods), importName(name).toTermName, tparams map importTypeDef, mmap(vparamss)(importValDef), importTree(tpt), importTree(rhs))
-        case from.TypeDef(mods, name, tparams, rhs) =>
-          new TypeDef(importModifiers(mods), importName(name).toTypeName, tparams map importTypeDef, importTree(rhs))
-        case from.LabelDef(name, params, rhs) =>
-          new LabelDef(importName(name).toTermName, params map importIdent, importTree(rhs))
-        case from.Import(expr, selectors) =>
-          new Import(importTree(expr), selectors map importImportSelector)
-        case from.Template(parents, self, body) =>
-          new Template(parents map importTree, importValDef(self), body map importTree)
-        case from.Block(stats, expr) =>
-          new Block(stats map importTree, importTree(expr))
-        case from.CaseDef(pat, guard, body) =>
-          new CaseDef(importTree(pat), importTree(guard), importTree(body))
-        case from.Alternative(trees) =>
-          new Alternative(trees map importTree)
-        case from.Star(elem) =>
-          new Star(importTree(elem))
-        case from.Bind(name, body) =>
-          new Bind(importName(name), importTree(body))
-        case from.UnApply(fun, args) =>
-          new UnApply(importTree(fun), args map importTree)
-        case from.ArrayValue(elemtpt ,elems) =>
-          new ArrayValue(importTree(elemtpt), elems map importTree)
-        case from.Function(vparams, body) =>
-          new Function(vparams map importValDef, importTree(body))
-        case from.Assign(lhs, rhs) =>
-          new Assign(importTree(lhs), importTree(rhs))
-        case from.AssignOrNamedArg(lhs, rhs) =>
-          new AssignOrNamedArg(importTree(lhs), importTree(rhs))
-        case from.If(cond, thenp, elsep) =>
-          new If(importTree(cond), importTree(thenp), importTree(elsep))
-        case from.Match(selector, cases) =>
-          new Match(importTree(selector), cases map importCaseDef)
-        case from.Return(expr) =>
-          new Return(importTree(expr))
-        case from.Try(block, catches, finalizer) =>
-          new Try(importTree(block), catches map importCaseDef, importTree(finalizer))
-        case from.Throw(expr) =>
-          new Throw(importTree(expr))
-        case from.New(tpt) =>
-          new New(importTree(tpt))
-        case from.Typed(expr, tpt) =>
-          new Typed(importTree(expr), importTree(tpt))
-        case from.TypeApply(fun, args) =>
-          new TypeApply(importTree(fun), args map importTree)
-        case from.Apply(fun, args) => tree match {
-          case _: from.ApplyToImplicitArgs =>
-            new ApplyToImplicitArgs(importTree(fun), args map importTree)
-          case _: from.ApplyImplicitView =>
-            new ApplyImplicitView(importTree(fun), args map importTree)
-          case _ =>
-            new Apply(importTree(fun), args map importTree)
-        }
-        case from.ApplyDynamic(qual, args) =>
-          new ApplyDynamic(importTree(qual), args map importTree)
-        case from.Super(qual, mix) =>
-          new Super(importTree(qual), importTypeName(mix))
-        case from.This(qual) =>
-          new This(importName(qual).toTypeName)
-        case from.Select(qual, name) =>
-          new Select(importTree(qual), importName(name))
-        case from.Ident(name) =>
-          new Ident(importName(name))
-        case from.ReferenceToBoxed(ident) =>
-          new ReferenceToBoxed(importTree(ident) match { case ident: Ident => ident })
-        case from.Literal(constant @ from.Constant(_)) =>
-          new Literal(importConstant(constant))
-        case from.TypeTree() =>
-          new TypeTree()
-        case from.Annotated(annot, arg) =>
-          new Annotated(importTree(annot), importTree(arg))
-        case from.SingletonTypeTree(ref) =>
-          new SingletonTypeTree(importTree(ref))
-        case from.SelectFromTypeTree(qual, name) =>
-          new SelectFromTypeTree(importTree(qual), importName(name).toTypeName)
-        case from.CompoundTypeTree(templ) =>
-          new CompoundTypeTree(importTemplate(templ))
-        case from.AppliedTypeTree(tpt, args) =>
-          new AppliedTypeTree(importTree(tpt), args map importTree)
-        case from.TypeBoundsTree(lo, hi) =>
-          new TypeBoundsTree(importTree(lo), importTree(hi))
-        case from.ExistentialTypeTree(tpt, whereClauses) =>
-          new ExistentialTypeTree(importTree(tpt), whereClauses map importTree)
-        case from.EmptyTree =>
-          EmptyTree
-        case null =>
-          null
-      }
-      addFixup({
-        if (mytree != null) {
-          val mysym = if (tree.hasSymbolField) importSymbol(tree.symbol) else NoSymbol
-          val mytpe = importType(tree.tpe)
-
-          mytree match {
-            case mytt: TypeTree =>
-              val tt = tree.asInstanceOf[from.TypeTree]
-              if (mytree.hasSymbolField) mytt.symbol = mysym
-              if (tt.wasEmpty) mytt.defineType(mytpe) else mytt.setType(mytpe)
-              if (tt.original != null) mytt.setOriginal(importTree(tt.original))
-            case _ =>
-              if (mytree.hasSymbolField) mytree.symbol = importSymbol(tree.symbol)
-              mytree setType importType(tree.tpe)
-          }
-        }
-      })
-      tryFixup()
-      mytree
-    }
-
     def importValDef(tree: from.ValDef): ValDef = importTree(tree).asInstanceOf[ValDef]
     def importTypeDef(tree: from.TypeDef): TypeDef = importTree(tree).asInstanceOf[TypeDef]
     def importTemplate(tree: from.Template): Template = importTree(tree).asInstanceOf[Template]