← Back to branch summary

~ubuntu-branches/debian/sid/scala/sid

« back to all changes in this revision

Viewing changes to src/reflect/scala/reflect/internal/Importers.scala

  • Committer: Package Import Robot
  • Author(s): Emmanuel Bourg, Mehdi Dogguy, Lucas Satabin, Frank S. Thomas, Emmanuel Bourg
  • Date: 2015-06-05 23:52:59 UTC
  • mfrom: (1.2.11)
  • Revision ID: package-import@ubuntu.com-20150605235259-wk00vgk83dh8o19g
Tags: 2.10.5-1
http://bugs.debian.org/744278
http://bugs.debian.org/754935
http://bugs.debian.org/724704
* Team upload.

[ Mehdi Dogguy ]
* New upstream release (Closes: #744278).

[ Lucas Satabin ]
* Update patches
* Update the clean target
* Update paths of elements to install
* Update watch file

[ Frank S. Thomas ]
* Remove myself from Uploaders.

[ Emmanuel Bourg ]
* The package has been adopted by the Java Team (Closes: #754935)
* Patched the build to avoid downloading libraries from the Internet
* Replaced the minified JavaScript files with unobfuscated ones
* No longer build scala-partest.jar until diffutils is packaged or replaced
* debian/watch: Fixed the versions matched (x.y.z instead of x.y.z..z)
* debian/rules:
  - Added the missing get-orig-source target (Closes: #724704)
  - Improved the clean target
* debian/control:
  - Build depend on scala (>= 2.10) and bnd
  - Use canonical URLs for the Vcs-* fields
  - Standards-Version updated to 3.9.6 (no changes)
* Switch to debhelper level 9

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/reflect/scala/reflect/internal/Importers.scala
 
1
package scala.reflect
 
2
package internal
 
3
 
 
4
import scala.collection.mutable.WeakHashMap
 
5
import scala.ref.WeakReference
 
6
 
 
7
// SI-6241: move importers to a mirror
 
8
trait Importers extends api.Importers { self: SymbolTable =>
 
9
 
 
10
  def mkImporter(from0: api.Universe): Importer { val from: from0.type } = (
 
11
    if (self eq from0) {
 
12
      new Importer {
 
13
        val from = from0
 
14
        val reverse = this.asInstanceOf[from.Importer{ val from: self.type }]
 
15
        def importSymbol(sym: from.Symbol) = sym.asInstanceOf[self.Symbol]
 
16
        def importType(tpe: from.Type) = tpe.asInstanceOf[self.Type]
 
17
        def importTree(tree: from.Tree) = tree.asInstanceOf[self.Tree]
 
18
        def importPosition(pos: from.Position) = pos.asInstanceOf[self.Position]
 
19
      }
 
20
    } else {
 
21
      // todo. fix this loophole
 
22
      assert(from0.isInstanceOf[SymbolTable], "`from` should be an instance of scala.reflect.internal.SymbolTable")
 
23
      new StandardImporter { val from = from0.asInstanceOf[SymbolTable] }
 
24
    }
 
25
  ).asInstanceOf[Importer { val from: from0.type }]
 
26
 
 
27
  abstract class StandardImporter extends Importer {
 
28
 
 
29
    val from: SymbolTable
 
30
 
 
31
    protected lazy val symMap = new Cache[from.Symbol, Symbol]()
 
32
    protected lazy val tpeMap = new Cache[from.Type, Type]()
 
33
    protected class Cache[K <: AnyRef, V <: AnyRef] extends WeakHashMap[K, WeakReference[V]] {
 
34
      def weakGet(key: K): Option[V] = this get key flatMap WeakReference.unapply
 
35
      def weakUpdate(key: K, value: V) = this.update(key, WeakReference(value))
 
36
    }
 
37
 
 
38
    // fixups and maps prevent stackoverflows in importer
 
39
    var pendingSyms = 0
 
40
    var pendingTpes = 0
 
41
    lazy val fixups = scala.collection.mutable.MutableList[Function0[Unit]]()
 
42
    def addFixup(fixup: => Unit): Unit = fixups += (() => fixup)
 
43
    def tryFixup(): Unit = {
 
44
      if (pendingSyms == 0 && pendingTpes == 0) {
 
45
        val fixups = this.fixups.toList
 
46
        this.fixups.clear()
 
47
        fixups foreach { _() }
 
48
      }
 
49
    }
 
50
 
 
51
    object reverse extends from.StandardImporter {
 
52
      val from: self.type = self
 
53
      // FIXME this and reverse should be constantly kept in sync
 
54
      // not just synced once upon the first usage of reverse
 
55
      for ((fromsym, WeakReference(mysym)) <- StandardImporter.this.symMap) symMap += ((mysym, WeakReference(fromsym)))
 
56
      for ((fromtpe, WeakReference(mytpe)) <- StandardImporter.this.tpeMap) tpeMap += ((mytpe, WeakReference(fromtpe)))
 
57
    }
 
58
 
 
59
    // todo. careful import of positions
 
60
    def importPosition(pos: from.Position): Position =
 
61
      pos.asInstanceOf[Position]
 
62
 
 
63
    def importSymbol(sym0: from.Symbol): Symbol = {
 
64
      def doImport(sym: from.Symbol): Symbol =
 
65
        symMap weakGet sym match {
 
66
          case Some(result) => result
 
67
          case _ =>
 
68
            val myowner = importSymbol(sym.owner)
 
69
            val mypos   = importPosition(sym.pos)
 
70
            val myname  = importName(sym.name).toTermName
 
71
            val myflags = sym.flags
 
72
            def linkReferenced(mysym: TermSymbol, x: from.TermSymbol, op: from.Symbol => Symbol): Symbol = {
 
73
              symMap.weakUpdate(x, mysym)
 
74
              mysym.referenced = op(x.referenced)
 
75
              mysym
 
76
            }
 
77
            val mysym = sym match {
 
78
              case x: from.MethodSymbol =>
 
79
                linkReferenced(myowner.newMethod(myname, mypos, myflags), x, importSymbol)
 
80
              case x: from.ModuleSymbol =>
 
81
                linkReferenced(myowner.newModuleSymbol(myname, mypos, myflags), x, importSymbol)
 
82
              case x: from.FreeTermSymbol =>
 
83
                newFreeTermSymbol(importName(x.name).toTermName, x.value, x.flags, x.origin) setInfo importType(x.info)
 
84
              case x: from.FreeTypeSymbol =>
 
85
                newFreeTypeSymbol(importName(x.name).toTypeName, x.flags, x.origin)
 
86
              case x: from.TermSymbol =>
 
87
                linkReferenced(myowner.newValue(myname, mypos, myflags), x, importSymbol)
 
88
              case x: from.TypeSkolem =>
 
89
                val origin = x.unpackLocation match {
 
90
                  case null           => null
 
91
                  case y: from.Tree   => importTree(y)
 
92
                  case y: from.Symbol => importSymbol(y)
 
93
                }
 
94
                myowner.newTypeSkolemSymbol(myname.toTypeName, origin, mypos, myflags)
 
95
              case x: from.ModuleClassSymbol =>
 
96
                val mysym = myowner.newModuleClass(myname.toTypeName, mypos, myflags)
 
97
                symMap.weakUpdate(x, mysym)
 
98
                mysym.sourceModule = importSymbol(x.sourceModule)
 
99
                mysym
 
100
              case x: from.ClassSymbol =>
 
101
                val mysym = myowner.newClassSymbol(myname.toTypeName, mypos, myflags)
 
102
                symMap.weakUpdate(x, mysym)
 
103
                if (sym.thisSym != sym) {
 
104
                  mysym.typeOfThis = importType(sym.typeOfThis)
 
105
                  mysym.thisSym setName importName(sym.thisSym.name)
 
106
                }
 
107
                mysym
 
108
              case x: from.TypeSymbol =>
 
109
                myowner.newTypeSymbol(myname.toTypeName, mypos, myflags)
 
110
            }
 
111
            symMap.weakUpdate(sym, mysym)
 
112
            mysym setFlag Flags.LOCKED
 
113
            mysym setInfo {
 
114
              val mytypeParams = sym.typeParams map importSymbol
 
115
              new LazyPolyType(mytypeParams) with FlagAgnosticCompleter {
 
116
                override def complete(s: Symbol) {
 
117
                  val result = sym.info match {
 
118
                    case from.PolyType(_, res) => res
 
119
                    case result => result
 
120
                  }
 
121
                  s setInfo GenPolyType(mytypeParams, importType(result))
 
122
                  s setAnnotations (sym.annotations map importAnnotationInfo)
 
123
                }
 
124
              }
 
125
            }
 
126
            mysym resetFlag Flags.LOCKED
 
127
        } // end doImport
 
128
 
 
129
      def importOrRelink: Symbol = {
 
130
        val sym = sym0 // makes sym visible in the debugger
 
131
        if (sym == null)
 
132
          null
 
133
        else if (sym == from.NoSymbol)
 
134
          NoSymbol
 
135
        else if (sym.isRoot)
 
136
          rootMirror.RootClass // !!! replace with actual mirror when we move importers to the mirror
 
137
        else {
 
138
          val name = sym.name
 
139
          val owner = sym.owner
 
140
          var scope = if (owner.isClass && !owner.isRefinementClass) owner.info else from.NoType
 
141
          var existing = scope.decl(name)
 
142
          if (sym.isModuleClass)
 
143
            existing = existing.moduleClass
 
144
 
 
145
          if (!existing.exists) scope = from.NoType
 
146
 
 
147
          val myname = importName(name)
 
148
          val myowner = importSymbol(owner)
 
149
          val myscope = if (scope != from.NoType && !(myowner hasFlag Flags.LOCKED)) myowner.info else NoType
 
150
          var myexisting = if (myscope != NoType) myowner.info.decl(myname) else NoSymbol // cannot load myexisting in general case, because it creates cycles for methods
 
151
          if (sym.isModuleClass)
 
152
            myexisting = importSymbol(sym.sourceModule).moduleClass
 
153
 
 
154
          if (!sym.isOverloaded && myexisting.isOverloaded) {
 
155
            myexisting =
 
156
              if (sym.isMethod) {
 
157
                val localCopy = doImport(sym)
 
158
                myexisting filter (_.tpe matches localCopy.tpe)
 
159
              } else {
 
160
                myexisting filter (!_.isMethod)
 
161
              }
 
162
            assert(!myexisting.isOverloaded,
 
163
                "import failure: cannot determine unique overloaded method alternative from\n "+
 
164
                (myexisting.alternatives map (_.defString) mkString "\n")+"\n that matches "+sym+":"+sym.tpe)
 
165
          }
 
166
 
 
167
          val mysym = {
 
168
            if (sym.isOverloaded) {
 
169
              myowner.newOverloaded(myowner.thisType, sym.alternatives map importSymbol)
 
170
            } else if (sym.isTypeParameter && sym.paramPos >= 0 && !(myowner hasFlag Flags.LOCKED)) {
 
171
              assert(myowner.typeParams.length > sym.paramPos,
 
172
                  "import failure: cannot determine parameter "+sym+" (#"+sym.paramPos+") in "+
 
173
                  myowner+typeParamsString(myowner.rawInfo)+"\n original symbol was: "+
 
174
                  sym.owner+from.typeParamsString(sym.owner.info))
 
175
              myowner.typeParams(sym.paramPos)
 
176
            } else {
 
177
              if (myexisting != NoSymbol) {
 
178
                myexisting
 
179
              } else {
 
180
                val mysym = doImport(sym)
 
181
 
 
182
                if (myscope != NoType) {
 
183
                  assert(myowner.info.decls.lookup(myname) == NoSymbol, myname+" "+myowner.info.decl(myname)+" "+myexisting)
 
184
                  myowner.info.decls enter mysym
 
185
                }
 
186
 
 
187
                mysym
 
188
              }
 
189
            }
 
190
          }
 
191
 
 
192
          mysym
 
193
        }
 
194
      } // end importOrRelink
 
195
 
 
196
      val sym = sym0
 
197
      symMap.weakGet(sym) match {
 
198
        case Some(result) => result
 
199
        case None =>
 
200
          pendingSyms += 1
 
201
          try {
 
202
            val result = importOrRelink
 
203
            symMap.weakUpdate(sym, result)
 
204
            result
 
205
          } finally {
 
206
            pendingSyms -= 1
 
207
            tryFixup()
 
208
          }
 
209
      }
 
210
    }
 
211
 
 
212
    def importType(tpe: from.Type): Type = {
 
213
      def doImport(tpe: from.Type): Type = tpe match {
 
214
        case from.TypeRef(pre, sym, args) =>
 
215
          TypeRef(importType(pre), importSymbol(sym), args map importType)
 
216
        case from.ThisType(clazz) =>
 
217
          ThisType(importSymbol(clazz))
 
218
        case from.SingleType(pre, sym) =>
 
219
          SingleType(importType(pre), importSymbol(sym))
 
220
        case from.MethodType(params, restpe) =>
 
221
          MethodType(params map importSymbol, importType(restpe))
 
222
        case from.PolyType(tparams, restpe) =>
 
223
          PolyType(tparams map importSymbol, importType(restpe))
 
224
        case from.NullaryMethodType(restpe) =>
 
225
          NullaryMethodType(importType(restpe))
 
226
        case from.ConstantType(constant @ from.Constant(_)) =>
 
227
          ConstantType(importConstant(constant))
 
228
        case from.SuperType(thistpe, supertpe) =>
 
229
          SuperType(importType(thistpe), importType(supertpe))
 
230
        case from.TypeBounds(lo, hi) =>
 
231
          TypeBounds(importType(lo), importType(hi))
 
232
        case from.BoundedWildcardType(bounds) =>
 
233
          BoundedWildcardType(importTypeBounds(bounds))
 
234
        case from.ClassInfoType(parents, decls, clazz) =>
 
235
          val myclazz = importSymbol(clazz)
 
236
          val myscope = if (myclazz.isPackageClass) newPackageScope(myclazz) else newScope
 
237
          val myclazzTpe = ClassInfoType(parents map importType, myscope, myclazz)
 
238
          myclazz setInfo GenPolyType(myclazz.typeParams, myclazzTpe) // needed so that newly created symbols find their scope
 
239
          decls foreach importSymbol // will enter itself into myclazz
 
240
          myclazzTpe
 
241
        case from.RefinedType(parents, decls) =>
 
242
          RefinedType(parents map importType, importScope(decls), importSymbol(tpe.typeSymbol))
 
243
        case from.ExistentialType(tparams, restpe) =>
 
244
          newExistentialType(tparams map importSymbol, importType(restpe))
 
245
        case from.OverloadedType(pre, alts) =>
 
246
          OverloadedType(importType(pre), alts map importSymbol)
 
247
        case from.AntiPolyType(pre, targs) =>
 
248
          AntiPolyType(importType(pre), targs map importType)
 
249
        case x: from.TypeVar =>
 
250
          TypeVar(importType(x.origin), importTypeConstraint(x.constr), x.typeArgs map importType, x.params map importSymbol)
 
251
        case from.NotNullType(tpe) =>
 
252
          NotNullType(importType(tpe))
 
253
        case from.AnnotatedType(annots, tpe, selfsym) =>
 
254
          AnnotatedType(annots map importAnnotationInfo, importType(tpe), importSymbol(selfsym))
 
255
        case from.ErrorType =>
 
256
          ErrorType
 
257
        case from.WildcardType =>
 
258
          WildcardType
 
259
        case from.NoType =>
 
260
          NoType
 
261
        case from.NoPrefix =>
 
262
          NoPrefix
 
263
        case null =>
 
264
          null
 
265
      } // end doImport
 
266
 
 
267
      def importOrRelink: Type =
 
268
        doImport(tpe)
 
269
 
 
270
      tpeMap.weakGet(tpe) match {
 
271
        case Some(result) => result
 
272
        case None =>
 
273
          pendingTpes += 1
 
274
          try {
 
275
            val result = importOrRelink
 
276
            tpeMap.weakUpdate(tpe, result)
 
277
            result
 
278
          } finally {
 
279
            pendingTpes -= 1
 
280
            tryFixup()
 
281
          }
 
282
      }
 
283
    }
 
284
 
 
285
    def importTypeBounds(bounds: from.TypeBounds) = importType(bounds).asInstanceOf[TypeBounds]
 
286
 
 
287
    def importAnnotationInfo(ann: from.AnnotationInfo): AnnotationInfo = {
 
288
      val atp1 = importType(ann.atp)
 
289
      val args1 = ann.args map importTree
 
290
      val assocs1 = ann.assocs map { case (name, arg) => (importName(name), importAnnotArg(arg)) }
 
291
      val original1 = importTree(ann.original)
 
292
      AnnotationInfo(atp1, args1, assocs1) setOriginal original1
 
293
    }
 
294
 
 
295
    def importAnnotArg(arg: from.ClassfileAnnotArg): ClassfileAnnotArg = arg match {
 
296
      case from.LiteralAnnotArg(constant @ from.Constant(_)) =>
 
297
        LiteralAnnotArg(importConstant(constant))
 
298
      case from.ArrayAnnotArg(args) =>
 
299
        ArrayAnnotArg(args map importAnnotArg)
 
300
      case from.ScalaSigBytes(bytes) =>
 
301
        ScalaSigBytes(bytes)
 
302
      case from.NestedAnnotArg(annInfo) =>
 
303
        NestedAnnotArg(importAnnotationInfo(annInfo))
 
304
    }
 
305
 
 
306
    def importTypeConstraint(constr: from.TypeConstraint): TypeConstraint = {
 
307
      val result = new TypeConstraint(constr.loBounds map importType, constr.hiBounds map importType)
 
308
      result.inst = importType(constr.inst)
 
309
      result
 
310
    }
 
311
 
 
312
    // !!! todo: override to cater for PackageScopes
 
313
    def importScope(decls: from.Scope): Scope =
 
314
      newScopeWith(decls.toList map importSymbol: _*)
 
315
 
 
316
    def importName(name: from.Name): Name =
 
317
      if (name.isTypeName) newTypeName(name.toString) else newTermName(name.toString)
 
318
    def importTypeName(name: from.TypeName): TypeName = importName(name).toTypeName
 
319
    def importTermName(name: from.TermName): TermName = importName(name).toTermName
 
320
 
 
321
    def importModifiers(mods: from.Modifiers): Modifiers =
 
322
      new Modifiers(mods.flags, importName(mods.privateWithin), mods.annotations map importTree)
 
323
 
 
324
    def importImportSelector(sel: from.ImportSelector): ImportSelector =
 
325
      new ImportSelector(importName(sel.name), sel.namePos, if (sel.rename != null) importName(sel.rename) else null, sel.renamePos)
 
326
 
 
327
    def importTree(tree: from.Tree): Tree = {
 
328
      val mytree = tree match {
 
329
        case from.ClassDef(mods, name, tparams, impl) =>
 
330
          new ClassDef(importModifiers(mods), importName(name).toTypeName, tparams map importTypeDef, importTemplate(impl))
 
331
        case from.PackageDef(pid, stats) =>
 
332
          new PackageDef(importRefTree(pid), stats map importTree)
 
333
        case from.ModuleDef(mods, name, impl) =>
 
334
          new ModuleDef(importModifiers(mods), importName(name).toTermName, importTemplate(impl))
 
335
        case from.emptyValDef =>
 
336
          emptyValDef
 
337
        case from.ValDef(mods, name, tpt, rhs) =>
 
338
          new ValDef(importModifiers(mods), importName(name).toTermName, importTree(tpt), importTree(rhs))
 
339
        case from.DefDef(mods, name, tparams, vparamss, tpt, rhs) =>
 
340
          new DefDef(importModifiers(mods), importName(name).toTermName, tparams map importTypeDef, mmap(vparamss)(importValDef), importTree(tpt), importTree(rhs))
 
341
        case from.TypeDef(mods, name, tparams, rhs) =>
 
342
          new TypeDef(importModifiers(mods), importName(name).toTypeName, tparams map importTypeDef, importTree(rhs))
 
343
        case from.LabelDef(name, params, rhs) =>
 
344
          new LabelDef(importName(name).toTermName, params map importIdent, importTree(rhs))
 
345
        case from.Import(expr, selectors) =>
 
346
          new Import(importTree(expr), selectors map importImportSelector)
 
347
        case from.Template(parents, self, body) =>
 
348
          new Template(parents map importTree, importValDef(self), body map importTree)
 
349
        case from.Block(stats, expr) =>
 
350
          new Block(stats map importTree, importTree(expr))
 
351
        case from.CaseDef(pat, guard, body) =>
 
352
          new CaseDef(importTree(pat), importTree(guard), importTree(body))
 
353
        case from.Alternative(trees) =>
 
354
          new Alternative(trees map importTree)
 
355
        case from.Star(elem) =>
 
356
          new Star(importTree(elem))
 
357
        case from.Bind(name, body) =>
 
358
          new Bind(importName(name), importTree(body))
 
359
        case from.UnApply(fun, args) =>
 
360
          new UnApply(importTree(fun), args map importTree)
 
361
        case from.ArrayValue(elemtpt ,elems) =>
 
362
          new ArrayValue(importTree(elemtpt), elems map importTree)
 
363
        case from.Function(vparams, body) =>
 
364
          new Function(vparams map importValDef, importTree(body))
 
365
        case from.Assign(lhs, rhs) =>
 
366
          new Assign(importTree(lhs), importTree(rhs))
 
367
        case from.AssignOrNamedArg(lhs, rhs) =>
 
368
          new AssignOrNamedArg(importTree(lhs), importTree(rhs))
 
369
        case from.If(cond, thenp, elsep) =>
 
370
          new If(importTree(cond), importTree(thenp), importTree(elsep))
 
371
        case from.Match(selector, cases) =>
 
372
          new Match(importTree(selector), cases map importCaseDef)
 
373
        case from.Return(expr) =>
 
374
          new Return(importTree(expr))
 
375
        case from.Try(block, catches, finalizer) =>
 
376
          new Try(importTree(block), catches map importCaseDef, importTree(finalizer))
 
377
        case from.Throw(expr) =>
 
378
          new Throw(importTree(expr))
 
379
        case from.New(tpt) =>
 
380
          new New(importTree(tpt))
 
381
        case from.Typed(expr, tpt) =>
 
382
          new Typed(importTree(expr), importTree(tpt))
 
383
        case from.TypeApply(fun, args) =>
 
384
          new TypeApply(importTree(fun), args map importTree)
 
385
        case from.Apply(fun, args) => tree match {
 
386
          case _: from.ApplyToImplicitArgs =>
 
387
            new ApplyToImplicitArgs(importTree(fun), args map importTree)
 
388
          case _: from.ApplyImplicitView =>
 
389
            new ApplyImplicitView(importTree(fun), args map importTree)
 
390
          case _ =>
 
391
            new Apply(importTree(fun), args map importTree)
 
392
        }
 
393
        case from.ApplyDynamic(qual, args) =>
 
394
          new ApplyDynamic(importTree(qual), args map importTree)
 
395
        case from.Super(qual, mix) =>
 
396
          new Super(importTree(qual), importTypeName(mix))
 
397
        case from.This(qual) =>
 
398
          new This(importName(qual).toTypeName)
 
399
        case from.Select(qual, name) =>
 
400
          new Select(importTree(qual), importName(name))
 
401
        case from.Ident(name) =>
 
402
          new Ident(importName(name))
 
403
        case from.ReferenceToBoxed(ident) =>
 
404
          new ReferenceToBoxed(importTree(ident) match { case ident: Ident => ident })
 
405
        case from.Literal(constant @ from.Constant(_)) =>
 
406
          new Literal(importConstant(constant))
 
407
        case from.TypeTree() =>
 
408
          new TypeTree()
 
409
        case from.Annotated(annot, arg) =>
 
410
          new Annotated(importTree(annot), importTree(arg))
 
411
        case from.SingletonTypeTree(ref) =>
 
412
          new SingletonTypeTree(importTree(ref))
 
413
        case from.SelectFromTypeTree(qual, name) =>
 
414
          new SelectFromTypeTree(importTree(qual), importName(name).toTypeName)
 
415
        case from.CompoundTypeTree(templ) =>
 
416
          new CompoundTypeTree(importTemplate(templ))
 
417
        case from.AppliedTypeTree(tpt, args) =>
 
418
          new AppliedTypeTree(importTree(tpt), args map importTree)
 
419
        case from.TypeBoundsTree(lo, hi) =>
 
420
          new TypeBoundsTree(importTree(lo), importTree(hi))
 
421
        case from.ExistentialTypeTree(tpt, whereClauses) =>
 
422
          new ExistentialTypeTree(importTree(tpt), whereClauses map importTree)
 
423
        case from.EmptyTree =>
 
424
          EmptyTree
 
425
        case null =>
 
426
          null
 
427
      }
 
428
      addFixup({
 
429
        if (mytree != null) {
 
430
          val mysym = if (tree.hasSymbol) importSymbol(tree.symbol) else NoSymbol
 
431
          val mytpe = importType(tree.tpe)
 
432
 
 
433
          mytree match {
 
434
            case mytt: TypeTree =>
 
435
              val tt = tree.asInstanceOf[from.TypeTree]
 
436
              if (mytree.hasSymbol) mytt.symbol = mysym
 
437
              if (tt.wasEmpty) mytt.defineType(mytpe) else mytt.setType(mytpe)
 
438
              if (tt.original != null) mytt.setOriginal(importTree(tt.original))
 
439
            case _ =>
 
440
              if (mytree.hasSymbol) mytree.symbol = importSymbol(tree.symbol)
 
441
              mytree.tpe = importType(tree.tpe)
 
442
          }
 
443
        }
 
444
      })
 
445
      tryFixup()
 
446
      // we have to be careful with position import as some shared trees
 
447
      // like EmptyTree, emptyValDef don't support position assignment
 
448
      if (tree.pos != NoPosition)
 
449
        mytree.setPos(importPosition(tree.pos))
 
450
      else
 
451
        mytree
 
452
    }
 
453
 
 
454
    def importValDef(tree: from.ValDef): ValDef = importTree(tree).asInstanceOf[ValDef]
 
455
    def importTypeDef(tree: from.TypeDef): TypeDef = importTree(tree).asInstanceOf[TypeDef]
 
456
    def importTemplate(tree: from.Template): Template = importTree(tree).asInstanceOf[Template]
 
457
    def importRefTree(tree: from.RefTree): RefTree = importTree(tree).asInstanceOf[RefTree]
 
458
    def importIdent(tree: from.Ident): Ident = importTree(tree).asInstanceOf[Ident]
 
459
    def importCaseDef(tree: from.CaseDef): CaseDef = importTree(tree).asInstanceOf[CaseDef]
 
460
    def importConstant(constant: from.Constant): Constant = new Constant(constant.tag match {
 
461
      case ClazzTag => importType(constant.value.asInstanceOf[from.Type])
 
462
      case EnumTag => importSymbol(constant.value.asInstanceOf[from.Symbol])
 
463
      case _ => constant.value
 
464
    })
 
465
  }
 
466
}