alvinalexander.com | career | drupal | java | mac | mysql | perl | scala | uml | unix  

Scala example source code file (Importers.scala)

This example Scala source code file (Importers.scala) is included in my "Source Code Warehouse" project. The intent of this project is to help you more easily find Scala source code examples by using tags.

All credit for the original source code belongs to scala-lang.org; I'm just trying to make examples easier to find. (For my Scala work, see my Scala examples and tutorials.)

Scala tags/keywords

annotationinfo, collection, ident, importer, k, mutable, nosymbol, notype, some, symbol, unit, weakreference

The Importers.scala Scala example source code

package scala
package reflect
package internal

import scala.collection.mutable.WeakHashMap
import scala.ref.WeakReference
import scala.reflect.internal.Flags._

// SI-6241: move importers to a mirror
trait Importers { to: SymbolTable =>

  override def mkImporter(from0: api.Universe): Importer { val from: from0.type } = (
    if (to eq from0) {
      new Importer {
        val from = from0
        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
      assert(from0.isInstanceOf[SymbolTable], "`from` should be an instance of scala.reflect.internal.SymbolTable")
      new StandardImporter { val from = from0.asInstanceOf[SymbolTable] }
    }
  ).asInstanceOf[Importer { val from: from0.type }]

  abstract class StandardImporter extends Importer {

    val from: SymbolTable

    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))
    }

    // fixups and maps prevent stackoverflows in importer
    var pendingSyms = 0
    var pendingTpes = 0
    lazy val fixups = scala.collection.mutable.MutableList[Function0[Unit]]()
    def addFixup(fixup: => Unit): Unit = fixups += (() => fixup)
    def tryFixup(): Unit = {
      if (pendingSyms == 0 && pendingTpes == 0) {
        val fixups = this.fixups.toList
        this.fixups.clear()
        fixups foreach { _() }
      }
    }

    object reverse extends from.StandardImporter {
      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 ((theirsym, WeakReference(mysym)) <- StandardImporter.this.symMap) symMap += ((mysym, WeakReference(theirsym)))
      for ((theirtpe, WeakReference(mytpe)) <- StandardImporter.this.tpeMap) tpeMap += ((mytpe, WeakReference(theirtpe)))
    }

    // ============== SYMBOLS ==============

    protected def recreatedSymbolCompleter(my: to.Symbol, their: from.Symbol) = {
      // we lock the symbol that is imported for a very short period of time
      // i.e. only for when type parameters of the symbol are being imported
      // the lock is used to communicate to the recursive importSymbol calls
      // that type parameters need to be created from scratch
      // because otherwise type parameters are imported by looking into owner.typeParams
      // which is obviously unavailable while the completer is being created
      try {
        my setFlag Flags.LOCKED
        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)
            markAllCompleted(my)
          }
        }
      } finally {
        my resetFlag Flags.LOCKED
      }
    }

    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)
      markFlagsCompleted(my)(mask = AllFlags)
      my setInfo recreatedSymbolCompleter(my, their)
    }

    def importSymbol(their0: from.Symbol): Symbol = {
      def cachedRecreateSymbol(their: from.Symbol): Symbol =
        symMap weakGet their match {
          case Some(result) => result
          case _ => recreateSymbol(their)
        }

      def recreateOrRelink: Symbol = {
        val their = their0 // makes their visible in the debugger
        if (their == null)
          null
        else if (their == from.NoSymbol)
          NoSymbol
        else if (their.isRoot)
          rootMirror.RootClass // !!! replace with actual mirror when we move importers to the mirror
        else {
          val isModuleClass = their.isModuleClass
          val isTparam = their.isTypeParameter && their.paramPos >= 0
          val isOverloaded = their.isOverloaded

          var theirscope = if (their.owner.isClass && !their.owner.isRefinementClass) their.owner.info else from.NoType
          val theirexisting = if (isModuleClass) theirscope.decl(their.name).moduleClass else theirscope.decl(their.name)
          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
          val myexisting = {
            if (isModuleClass) importSymbol(their.sourceModule).moduleClass
            else if (isTparam) (if (myowner hasFlag Flags.LOCKED) NoSymbol else myowner.typeParams(their.paramPos))
            else if (isOverloaded) myowner.newOverloaded(myowner.thisType, their.alternatives map importSymbol)
            else {
              def disambiguate(my: Symbol) = {
                val result =
                  if (their.isMethod) {
                    val localCopy = cachedRecreateSymbol(their)
                    my filter (_.tpe matches localCopy.tpe)
                  } else {
                    my filter (!_.isMethod)
                  }
                assert(!result.isOverloaded,
                    "import failure: cannot determine unique overloaded method alternative from\n "+
                    (result.alternatives map (_.defString) mkString "\n")+"\n that matches "+their+":"+their.tpe)
                result
              }

              val myexisting = if (myscope != NoType) myscope.decl(myname) else NoSymbol
              if (myexisting.isOverloaded) disambiguate(myexisting)
              else myexisting
            }
          }

          myexisting.orElse {
            val my = cachedRecreateSymbol(their)
            if (myscope != NoType) {
              assert(myscope.decls.lookup(myname) == NoSymbol, myname+" "+myscope.decl(myname)+" "+myexisting)
              myscope.decls enter my
            }
            my
          }
        }
      } // end recreateOrRelink

      val their = their0
      symMap.weakGet(their) match {
        case Some(result) => result
        case None =>
          pendingSyms += 1
          try {
            val result = recreateOrRelink
            symMap.weakUpdate(their, result)
            result
          } finally {
            pendingSyms -= 1
            tryFixup()
          }
      }
    }

    // ============== 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.ImportType(qual) =>
        ImportType(importTree(qual))
      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) =>
        AnnotatedType(annots map importAnnotationInfo, importType(result))
      case from.ErrorType =>
        ErrorType
      case from.WildcardType =>
        WildcardType
      case from.NoType =>
        NoType
      case from.NoPrefix =>
        NoPrefix
      case null =>
        null
    }

    def importType(their: from.Type): Type = {
      tpeMap.weakGet(their) match {
        case Some(result) => result
        case None =>
          pendingTpes += 1
          try {
            val result = recreateType(their)
            tpeMap.weakUpdate(their, result)
            result
          } finally {
            pendingTpes -= 1
            tryFixup()
          }
      }
    }

    // ============== 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.noSelfType =>
        noSelfType
      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 importMemberDef)
      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()
        // we have to be careful with position import as some shared trees
        // like EmptyTree, noSelfType don't support position assignment
        if (their.pos != NoPosition) {
          my.setPos(importPosition(their.pos))
        }
      }
      importAttachments(their.attachments.all).foreach { my.updateAttachment(_) }
      my
    }

    // ============== MISCELLANEOUS ==============

    def importAttachments(attachments: Set[Any]): Set[Any] =
      attachments.collect { case ia: ImportableAttachment => ia.importAttachment(this) }

    def importAnnotationInfo(ann: from.AnnotationInfo): AnnotationInfo = {
      val atp1 = importType(ann.atp)
      val args1 = ann.args map importTree
      val assocs1 = ann.assocs map { case (name, arg) => (importName(name), importAnnotArg(arg)) }
      val original1 = importTree(ann.original)
      AnnotationInfo(atp1, args1, assocs1) setOriginal original1
    }

    def importAnnotArg(arg: from.ClassfileAnnotArg): ClassfileAnnotArg = arg match {
      case from.LiteralAnnotArg(constant @ from.Constant(_)) =>
        LiteralAnnotArg(importConstant(constant))
      case from.ArrayAnnotArg(args) =>
        ArrayAnnotArg(args map importAnnotArg)
      case from.ScalaSigBytes(bytes) =>
        ScalaSigBytes(bytes)
      case from.NestedAnnotArg(annInfo) =>
        NestedAnnotArg(importAnnotationInfo(annInfo))
      case from.UnmappableAnnotArg =>
        UnmappableAnnotArg
    }

    // 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 =
      newScopeWith(decls.toList map importSymbol: _*)

    def importName(name: from.Name): Name =
      if (name.isTypeName) newTypeName(name.toString) else newTermName(name.toString)

    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 importValDef(tree: from.ValDef): ValDef = importTree(tree).asInstanceOf[ValDef]
    def importTypeDef(tree: from.TypeDef): TypeDef = importTree(tree).asInstanceOf[TypeDef]
    def importMemberDef(tree: from.MemberDef): MemberDef = importTree(tree).asInstanceOf[MemberDef]
    def importTemplate(tree: from.Template): Template = importTree(tree).asInstanceOf[Template]
    def importRefTree(tree: from.RefTree): RefTree = importTree(tree).asInstanceOf[RefTree]
    def importIdent(tree: from.Ident): Ident = importTree(tree).asInstanceOf[Ident]
    def importCaseDef(tree: from.CaseDef): CaseDef = importTree(tree).asInstanceOf[CaseDef]
    def importConstant(constant: from.Constant): Constant = new Constant(constant.tag match {
      case ClazzTag => importType(constant.value.asInstanceOf[from.Type])
      case EnumTag => importSymbol(constant.value.asInstanceOf[from.Symbol])
      case _ => constant.value
    })
  }
}

Other Scala source code examples

Here is a short list of links related to this Scala Importers.scala source code file:

... this post is sponsored by my books ...

#1 New Release!

FP Best Seller

 

new blog posts

 

Copyright 1998-2024 Alvin Alexander, alvinalexander.com
All Rights Reserved.

A percentage of advertising revenue from
pages under the /java/jwarehouse URI on this website is
paid back to open source projects.