Scala example source code file (GenTrees.scala)

This example Scala source code file (GenTrees.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

boolean, emptytree, error, ident, nosymbol, reflection, reftree, reify, select, selectfromtypetree, this, tree

The GenTrees.scala Scala example source code

package scala.reflect.reify
package codegen

trait GenTrees {
  self: Reifier =>

  import global._
  import definitions._

  // unfortunately, these are necessary to reify AnnotatedTypes
  // I'd gladly get rid of them, but I don't fancy making a metaprogramming API that doesn't work with annotated types
  // luckily for our sanity, these vars are mutated only within a very restricted code execution path
  def reifyTreeSymbols: Boolean = state.reifyTreeSymbols
  def reifyTreeTypes: Boolean = state.reifyTreeTypes

  /**
   *  Reify a tree.
   *  For internal use only, use `reified` instead.
   */
  def reifyTree(tree: Tree): Tree = {
    assert(tree != null, "tree is null")

    if (tree.isErroneous)
      CannotReifyErroneousReifee(tree)

    val splicedTree = spliceTree(tree)
    if (splicedTree != EmptyTree)
      return splicedTree

    // the idea behind the new reincarnation of reifier is a simple maxim:
    //
    //   never call `reifyType` to reify a tree
    //
    // this works because the stuff we are reifying was once represented with trees only
    // and lexical scope information can be fully captured by reifying symbols
    //
    // to enable this idyll, we work hard in the `Reshape` phase
    // which replaces all types with equivalent trees and works around non-idempotencies of the typechecker
    //
    // why bother? because this brings method to the madness
    // the first prototype of reification reified all types and symbols for all trees => this quickly became unyieldy
    // the second prototype reified external types, but avoided reifying ones local to the reifee => this created an ugly irregularity
    // current approach is uniform and compact
    var rtree: Tree = tree match {
      case FreeDef(_, _, _, _, _) => reifyNestedFreeDef(tree)
      case FreeRef(_, _)          => reifyNestedFreeRef(tree)
      case BoundTerm(tree)        => reifyBoundTerm(tree)
      case BoundType(tree)        => reifyBoundType(tree)
      case _                      => reifyTreeSyntactically(tree)
    }

    // usually we don't reify symbols/types, because they can be re-inferred during subsequent reflective compilation
    // however, reification of AnnotatedTypes is special. see `reifyType` to find out why.
    if (reifyTreeSymbols && tree.hasSymbolField) {
      if (reifyDebug) println("reifying symbol %s for tree %s".format(tree.symbol, tree))
      rtree = mirrorBuildCall(nme.setSymbol, rtree, reify(tree.symbol))
    }
    if (reifyTreeTypes && tree.tpe != null) {
      if (reifyDebug) println("reifying type %s for tree %s".format(tree.tpe, tree))
      rtree = mirrorBuildCall(nme.setType, rtree, reify(tree.tpe))
    }

    rtree
  }

  def reifyTreeSyntactically(tree: Tree): Tree = tree match {
    case global.EmptyTree             => reifyMirrorObject(EmptyTree)
    case global.noSelfType            => mirrorSelect(nme.noSelfType)
    case global.pendingSuperCall      => mirrorSelect(nme.pendingSuperCall)
    case Literal(const @ Constant(_)) => mirrorCall(nme.Literal, reifyProduct(const))
    case Import(expr, selectors)      => mirrorCall(nme.Import, reify(expr), mkList(selectors map reifyProduct))
    case _                            => reifyProduct(tree)
  }

  def reifyFlags(flags: FlagSet) =
    if (flags != 0) reifyBuildCall(nme.FlagsRepr, flags) else mirrorSelect(nme.NoFlags)

  def reifyModifiers(m: global.Modifiers) =
    if (m == NoMods) mirrorSelect(nme.NoMods)
    else mirrorFactoryCall(nme.Modifiers, reifyFlags(m.flags), reify(m.privateWithin), reify(m.annotations))

  private def spliceTree(tree: Tree): Tree = {
    tree match {
      case TreeSplice(splicee) =>
        if (reifyDebug) println("splicing " + tree)

        // see `Metalevels` for more info about metalevel breaches
        // and about how we deal with splices that contain them
        val isMetalevelBreach = splicee exists (sub => sub.hasSymbolField && sub.symbol != NoSymbol && sub.symbol.metalevel > 0)
        val isRuntimeEval = splicee exists (sub => sub.hasSymbolField && sub.symbol == ExprSplice)
        if (isMetalevelBreach || isRuntimeEval) {
          // we used to convert dynamic splices into runtime evals transparently, but we no longer do that
          // why? see comments in `Metalevels`
          // if (reifyDebug) println("splicing has failed: cannot splice when facing a metalevel breach")
          // EmptyTree
          CannotReifyRuntimeSplice(tree)
        } else {
          if (reifyDebug) println("splicing has succeeded")
          splicee match {
            // we intentionally don't care about the prefix (the first underscore in the `RefiedTree` pattern match)
            case ReifiedTree(_, _, inlinedSymtab, rtree, _, _, _) =>
              if (reifyDebug) println("inlining the splicee")
              // all free vars local to the enclosing reifee should've already been inlined by `Metalevels`
              for (sym <- inlinedSymtab.syms if sym.isLocalToReifee)
                abort("free var local to the reifee, should have already been inlined by Metalevels: " + inlinedSymtab.symDef(sym))
              state.symtab ++= inlinedSymtab
              rtree
            case tree =>
              val migrated = Apply(Select(splicee, nme.in), List(Ident(nme.MIRROR_SHORT)))
              Select(migrated, nme.tree)
          }
        }
      case _ =>
        EmptyTree
    }
  }

  // unlike in `reifyBoundType` we can skip checking for `tpe` being local or not local w.r.t the reifee
  // a single check for a symbol of the bound term should be enough
  // that's because only Idents and Thises can be bound terms, and they cannot host complex types
  private def reifyBoundTerm(tree: Tree): Tree = {
    val sym = tree.symbol

    tree match {
      case This(qual) =>
        assert(sym != NoSymbol, "unexpected: bound term that doesn't have a symbol: " + showRaw(tree))
        if (sym.isLocalToReifee)
          mirrorCall(nme.This, reify(qual))
        else if (sym.isClass && !sym.isModuleClass) {
          if (reifyDebug) println("This for %s, reified as freeVar".format(sym))
          if (reifyDebug) println("Free: " + sym)
          mirrorBuildCall(nme.mkIdent, reifyFreeTerm(This(sym)))
        }
        else {
          if (reifyDebug) println("This for %s, reified as This".format(sym))
          mirrorBuildCall(nme.mkThis, reify(sym))
        }

      case Ident(name) =>
        if (sym == NoSymbol) {
          // this sometimes happens, e.g. for binds that don't have a body
          // or for untyped code generated during previous phases
          // (see a comment in Reifiers about the latter, starting with "why do we reset attrs?")
          mirrorCall(nme.Ident, reify(name))
        }
        else if (!sym.isLocalToReifee) {
          if (sym.isVariable && sym.owner.isTerm) {
            captureVariable(sym) // Note order dependency: captureVariable needs to come before reification here.
            mirrorCall(nme.Select, mirrorBuildCall(nme.mkIdent, reify(sym)), reify(nme.elem))
          }
          else mirrorBuildCall(nme.mkIdent, reify(sym))
        }
        else mirrorCall(nme.Ident, reify(name))

      case Select(qual, name) =>
        if (qual.symbol != null && qual.symbol.isPackage) {
          mirrorBuildCall(nme.mkIdent, reify(sym))
        } else {
          val effectiveName = if (sym != null && sym != NoSymbol) sym.name else name
          reifyProduct(Select(qual, effectiveName))
        }

      case _ =>
        throw new Error("internal error: %s (%s, %s) is not supported".format(tree, tree.productPrefix, tree.getClass))
    }
  }

  private def reifyBoundType(tree: RefTree): Tree = {
    val sym = tree.symbol
    val tpe = tree.tpe

    def reifyBoundType(tree: RefTree): Tree = {
      assert(tpe != null, "unexpected: bound type that doesn't have a tpe: " + showRaw(tree))

      // if a symbol or a type of the scrutinee are local to reifee
      // (e.g. point to a locally declared class or to a path-dependent thingie that depends on a variable defined within the reifee)
      // then we can reify the scrutinee as a symless AST and that will definitely be hygienic
      // why? because then typechecking of a scrutinee doesn't depend on the environment external to the quasiquote
      // otherwise we need to reify the corresponding type
      if (sym.isLocalToReifee || tpe.isLocalToReifee || treeInfo.isWildcardStarType(tree))
        reifyProduct(tree)
      else {
        if (reifyDebug) println("reifying bound type %s (underlying type is %s)".format(sym, tpe))

        if (tpe.isSpliceable) {
          val spliced = spliceType(tpe)

          if (spliced == EmptyTree) {
            if (reifyDebug) println("splicing failed: reify as is")
            mirrorBuildCall(nme.mkTypeTree, reify(tpe))
          }
          else spliced match {
            case TypeRefToFreeType(freeType) =>
              if (reifyDebug) println("splicing returned a free type: " + freeType)
              Ident(freeType)
            case _ =>
              if (reifyDebug) println("splicing succeeded: " + spliced)
              mirrorBuildCall(nme.mkTypeTree, spliced)
          }
        }
        else tree match {
          case Select(qual, name) if !qual.symbol.isPackage =>
            if (reifyDebug) println(s"reifying Select($qual, $name)")
            mirrorCall(nme.Select, reify(qual), reify(name))
          case SelectFromTypeTree(qual, name) =>
            if (reifyDebug) println(s"reifying SelectFromTypeTree($qual, $name)")
            mirrorCall(nme.SelectFromTypeTree, reify(qual), reify(name))
          case _ if sym.isLocatable =>
            if (reifyDebug) println(s"tpe is locatable: reify as Ident($sym)")
            mirrorBuildCall(nme.mkIdent, reify(sym))
          case _ =>
            if (reifyDebug) println(s"tpe is not locatable: reify as TypeTree($tpe)")
            mirrorBuildCall(nme.mkTypeTree, reify(tpe))
        }
      }
    }

    tree match {
      case Select(qual, name) if name != sym.name =>
        reifyBoundType(Select(qual, sym.name))

      case Select(_, _) | SelectFromTypeTree(_, _) | Ident(_) =>
        reifyBoundType(tree)

      case _ =>
        throw new Error("internal error: %s (%s, %s) is not supported".format(tree, tree.productPrefix, tree.getClass))
    }
  }

  private def reifyNestedFreeDef(tree: Tree): Tree = {
    if (reifyDebug) println("nested free def: %s".format(showRaw(tree)))
    reifyProduct(tree)
  }

  private def reifyNestedFreeRef(tree: Tree): Tree = {
    if (reifyDebug) println("nested free ref: %s".format(showRaw(tree)))
    reifyProduct(tree)
  }
}